1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(_curses_window_addch__doc__,
6"addch([y, x,] ch, [attr=_curses.A_NORMAL])\n"
7"Paint the character.\n"
8"\n"
9" y\n"
10" Y-coordinate.\n"
11" x\n"
12" X-coordinate.\n"
13" ch\n"
14" Character to add.\n"
15" attr\n"
16" Attributes for the character.\n"
17"\n"
18"Paint character ch at (y, x) with attributes attr,\n"
19"overwriting any character previously painted at that location.\n"
20"By default, the character position and attributes are the\n"
21"current settings for the window object.");
22
23#define _CURSES_WINDOW_ADDCH_METHODDEF \
24 {"addch", (PyCFunction)_curses_window_addch, METH_VARARGS, _curses_window_addch__doc__},
25
26static PyObject *
27_curses_window_addch_impl(PyCursesWindowObject *self, int group_left_1,
28 int y, int x, PyObject *ch, int group_right_1,
29 long attr);
30
31static PyObject *
32_curses_window_addch(PyCursesWindowObject *self, PyObject *args)
33{
34 PyObject *return_value = NULL;
35 int group_left_1 = 0;
36 int y = 0;
37 int x = 0;
38 PyObject *ch;
39 int group_right_1 = 0;
40 long attr = A_NORMAL;
41
42 switch (PyTuple_GET_SIZE(args)) {
43 case 1:
44 if (!PyArg_ParseTuple(args, "O:addch", &ch)) {
45 goto exit;
46 }
47 break;
48 case 2:
49 if (!PyArg_ParseTuple(args, "Ol:addch", &ch, &attr)) {
50 goto exit;
51 }
52 group_right_1 = 1;
53 break;
54 case 3:
55 if (!PyArg_ParseTuple(args, "iiO:addch", &y, &x, &ch)) {
56 goto exit;
57 }
58 group_left_1 = 1;
59 break;
60 case 4:
61 if (!PyArg_ParseTuple(args, "iiOl:addch", &y, &x, &ch, &attr)) {
62 goto exit;
63 }
64 group_right_1 = 1;
65 group_left_1 = 1;
66 break;
67 default:
68 PyErr_SetString(PyExc_TypeError, "_curses.window.addch requires 1 to 4 arguments");
69 goto exit;
70 }
71 return_value = _curses_window_addch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
72
73exit:
74 return return_value;
75}
76
77PyDoc_STRVAR(_curses_window_addstr__doc__,
78"addstr([y, x,] str, [attr])\n"
79"Paint the string.\n"
80"\n"
81" y\n"
82" Y-coordinate.\n"
83" x\n"
84" X-coordinate.\n"
85" str\n"
86" String to add.\n"
87" attr\n"
88" Attributes for characters.\n"
89"\n"
90"Paint the string str at (y, x) with attributes attr,\n"
91"overwriting anything previously on the display.\n"
92"By default, the character position and attributes are the\n"
93"current settings for the window object.");
94
95#define _CURSES_WINDOW_ADDSTR_METHODDEF \
96 {"addstr", (PyCFunction)_curses_window_addstr, METH_VARARGS, _curses_window_addstr__doc__},
97
98static PyObject *
99_curses_window_addstr_impl(PyCursesWindowObject *self, int group_left_1,
100 int y, int x, PyObject *str, int group_right_1,
101 long attr);
102
103static PyObject *
104_curses_window_addstr(PyCursesWindowObject *self, PyObject *args)
105{
106 PyObject *return_value = NULL;
107 int group_left_1 = 0;
108 int y = 0;
109 int x = 0;
110 PyObject *str;
111 int group_right_1 = 0;
112 long attr = 0;
113
114 switch (PyTuple_GET_SIZE(args)) {
115 case 1:
116 if (!PyArg_ParseTuple(args, "O:addstr", &str)) {
117 goto exit;
118 }
119 break;
120 case 2:
121 if (!PyArg_ParseTuple(args, "Ol:addstr", &str, &attr)) {
122 goto exit;
123 }
124 group_right_1 = 1;
125 break;
126 case 3:
127 if (!PyArg_ParseTuple(args, "iiO:addstr", &y, &x, &str)) {
128 goto exit;
129 }
130 group_left_1 = 1;
131 break;
132 case 4:
133 if (!PyArg_ParseTuple(args, "iiOl:addstr", &y, &x, &str, &attr)) {
134 goto exit;
135 }
136 group_right_1 = 1;
137 group_left_1 = 1;
138 break;
139 default:
140 PyErr_SetString(PyExc_TypeError, "_curses.window.addstr requires 1 to 4 arguments");
141 goto exit;
142 }
143 return_value = _curses_window_addstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
144
145exit:
146 return return_value;
147}
148
149PyDoc_STRVAR(_curses_window_addnstr__doc__,
150"addnstr([y, x,] str, n, [attr])\n"
151"Paint at most n characters of the string.\n"
152"\n"
153" y\n"
154" Y-coordinate.\n"
155" x\n"
156" X-coordinate.\n"
157" str\n"
158" String to add.\n"
159" n\n"
160" Maximal number of characters.\n"
161" attr\n"
162" Attributes for characters.\n"
163"\n"
164"Paint at most n characters of the string str at (y, x) with\n"
165"attributes attr, overwriting anything previously on the display.\n"
166"By default, the character position and attributes are the\n"
167"current settings for the window object.");
168
169#define _CURSES_WINDOW_ADDNSTR_METHODDEF \
170 {"addnstr", (PyCFunction)_curses_window_addnstr, METH_VARARGS, _curses_window_addnstr__doc__},
171
172static PyObject *
173_curses_window_addnstr_impl(PyCursesWindowObject *self, int group_left_1,
174 int y, int x, PyObject *str, int n,
175 int group_right_1, long attr);
176
177static PyObject *
178_curses_window_addnstr(PyCursesWindowObject *self, PyObject *args)
179{
180 PyObject *return_value = NULL;
181 int group_left_1 = 0;
182 int y = 0;
183 int x = 0;
184 PyObject *str;
185 int n;
186 int group_right_1 = 0;
187 long attr = 0;
188
189 switch (PyTuple_GET_SIZE(args)) {
190 case 2:
191 if (!PyArg_ParseTuple(args, "Oi:addnstr", &str, &n)) {
192 goto exit;
193 }
194 break;
195 case 3:
196 if (!PyArg_ParseTuple(args, "Oil:addnstr", &str, &n, &attr)) {
197 goto exit;
198 }
199 group_right_1 = 1;
200 break;
201 case 4:
202 if (!PyArg_ParseTuple(args, "iiOi:addnstr", &y, &x, &str, &n)) {
203 goto exit;
204 }
205 group_left_1 = 1;
206 break;
207 case 5:
208 if (!PyArg_ParseTuple(args, "iiOil:addnstr", &y, &x, &str, &n, &attr)) {
209 goto exit;
210 }
211 group_right_1 = 1;
212 group_left_1 = 1;
213 break;
214 default:
215 PyErr_SetString(PyExc_TypeError, "_curses.window.addnstr requires 2 to 5 arguments");
216 goto exit;
217 }
218 return_value = _curses_window_addnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
219
220exit:
221 return return_value;
222}
223
224PyDoc_STRVAR(_curses_window_bkgd__doc__,
225"bkgd($self, ch, attr=_curses.A_NORMAL, /)\n"
226"--\n"
227"\n"
228"Set the background property of the window.\n"
229"\n"
230" ch\n"
231" Background character.\n"
232" attr\n"
233" Background attributes.");
234
235#define _CURSES_WINDOW_BKGD_METHODDEF \
236 {"bkgd", (PyCFunction)(void(*)(void))_curses_window_bkgd, METH_FASTCALL, _curses_window_bkgd__doc__},
237
238static PyObject *
239_curses_window_bkgd_impl(PyCursesWindowObject *self, PyObject *ch, long attr);
240
241static PyObject *
242_curses_window_bkgd(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
243{
244 PyObject *return_value = NULL;
245 PyObject *ch;
246 long attr = A_NORMAL;
247
248 if (!_PyArg_CheckPositional("bkgd", nargs, 1, 2)) {
249 goto exit;
250 }
251 ch = args[0];
252 if (nargs < 2) {
253 goto skip_optional;
254 }
255 attr = PyLong_AsLong(args[1]);
256 if (attr == -1 && PyErr_Occurred()) {
257 goto exit;
258 }
259skip_optional:
260 return_value = _curses_window_bkgd_impl(self, ch, attr);
261
262exit:
263 return return_value;
264}
265
266PyDoc_STRVAR(_curses_window_attroff__doc__,
267"attroff($self, attr, /)\n"
268"--\n"
269"\n"
270"Remove attribute attr from the \"background\" set.");
271
272#define _CURSES_WINDOW_ATTROFF_METHODDEF \
273 {"attroff", (PyCFunction)_curses_window_attroff, METH_O, _curses_window_attroff__doc__},
274
275static PyObject *
276_curses_window_attroff_impl(PyCursesWindowObject *self, long attr);
277
278static PyObject *
279_curses_window_attroff(PyCursesWindowObject *self, PyObject *arg)
280{
281 PyObject *return_value = NULL;
282 long attr;
283
284 attr = PyLong_AsLong(arg);
285 if (attr == -1 && PyErr_Occurred()) {
286 goto exit;
287 }
288 return_value = _curses_window_attroff_impl(self, attr);
289
290exit:
291 return return_value;
292}
293
294PyDoc_STRVAR(_curses_window_attron__doc__,
295"attron($self, attr, /)\n"
296"--\n"
297"\n"
298"Add attribute attr from the \"background\" set.");
299
300#define _CURSES_WINDOW_ATTRON_METHODDEF \
301 {"attron", (PyCFunction)_curses_window_attron, METH_O, _curses_window_attron__doc__},
302
303static PyObject *
304_curses_window_attron_impl(PyCursesWindowObject *self, long attr);
305
306static PyObject *
307_curses_window_attron(PyCursesWindowObject *self, PyObject *arg)
308{
309 PyObject *return_value = NULL;
310 long attr;
311
312 attr = PyLong_AsLong(arg);
313 if (attr == -1 && PyErr_Occurred()) {
314 goto exit;
315 }
316 return_value = _curses_window_attron_impl(self, attr);
317
318exit:
319 return return_value;
320}
321
322PyDoc_STRVAR(_curses_window_attrset__doc__,
323"attrset($self, attr, /)\n"
324"--\n"
325"\n"
326"Set the \"background\" set of attributes.");
327
328#define _CURSES_WINDOW_ATTRSET_METHODDEF \
329 {"attrset", (PyCFunction)_curses_window_attrset, METH_O, _curses_window_attrset__doc__},
330
331static PyObject *
332_curses_window_attrset_impl(PyCursesWindowObject *self, long attr);
333
334static PyObject *
335_curses_window_attrset(PyCursesWindowObject *self, PyObject *arg)
336{
337 PyObject *return_value = NULL;
338 long attr;
339
340 attr = PyLong_AsLong(arg);
341 if (attr == -1 && PyErr_Occurred()) {
342 goto exit;
343 }
344 return_value = _curses_window_attrset_impl(self, attr);
345
346exit:
347 return return_value;
348}
349
350PyDoc_STRVAR(_curses_window_bkgdset__doc__,
351"bkgdset($self, ch, attr=_curses.A_NORMAL, /)\n"
352"--\n"
353"\n"
354"Set the window\'s background.\n"
355"\n"
356" ch\n"
357" Background character.\n"
358" attr\n"
359" Background attributes.");
360
361#define _CURSES_WINDOW_BKGDSET_METHODDEF \
362 {"bkgdset", (PyCFunction)(void(*)(void))_curses_window_bkgdset, METH_FASTCALL, _curses_window_bkgdset__doc__},
363
364static PyObject *
365_curses_window_bkgdset_impl(PyCursesWindowObject *self, PyObject *ch,
366 long attr);
367
368static PyObject *
369_curses_window_bkgdset(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
370{
371 PyObject *return_value = NULL;
372 PyObject *ch;
373 long attr = A_NORMAL;
374
375 if (!_PyArg_CheckPositional("bkgdset", nargs, 1, 2)) {
376 goto exit;
377 }
378 ch = args[0];
379 if (nargs < 2) {
380 goto skip_optional;
381 }
382 attr = PyLong_AsLong(args[1]);
383 if (attr == -1 && PyErr_Occurred()) {
384 goto exit;
385 }
386skip_optional:
387 return_value = _curses_window_bkgdset_impl(self, ch, attr);
388
389exit:
390 return return_value;
391}
392
393PyDoc_STRVAR(_curses_window_border__doc__,
394"border($self, ls=_curses.ACS_VLINE, rs=_curses.ACS_VLINE,\n"
395" ts=_curses.ACS_HLINE, bs=_curses.ACS_HLINE,\n"
396" tl=_curses.ACS_ULCORNER, tr=_curses.ACS_URCORNER,\n"
397" bl=_curses.ACS_LLCORNER, br=_curses.ACS_LRCORNER, /)\n"
398"--\n"
399"\n"
400"Draw a border around the edges of the window.\n"
401"\n"
402" ls\n"
403" Left side.\n"
404" rs\n"
405" Right side.\n"
406" ts\n"
407" Top side.\n"
408" bs\n"
409" Bottom side.\n"
410" tl\n"
411" Upper-left corner.\n"
412" tr\n"
413" Upper-right corner.\n"
414" bl\n"
415" Bottom-left corner.\n"
416" br\n"
417" Bottom-right corner.\n"
418"\n"
419"Each parameter specifies the character to use for a specific part of the\n"
420"border. The characters can be specified as integers or as one-character\n"
421"strings. A 0 value for any parameter will cause the default character to be\n"
422"used for that parameter.");
423
424#define _CURSES_WINDOW_BORDER_METHODDEF \
425 {"border", (PyCFunction)(void(*)(void))_curses_window_border, METH_FASTCALL, _curses_window_border__doc__},
426
427static PyObject *
428_curses_window_border_impl(PyCursesWindowObject *self, PyObject *ls,
429 PyObject *rs, PyObject *ts, PyObject *bs,
430 PyObject *tl, PyObject *tr, PyObject *bl,
431 PyObject *br);
432
433static PyObject *
434_curses_window_border(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
435{
436 PyObject *return_value = NULL;
437 PyObject *ls = NULL;
438 PyObject *rs = NULL;
439 PyObject *ts = NULL;
440 PyObject *bs = NULL;
441 PyObject *tl = NULL;
442 PyObject *tr = NULL;
443 PyObject *bl = NULL;
444 PyObject *br = NULL;
445
446 if (!_PyArg_CheckPositional("border", nargs, 0, 8)) {
447 goto exit;
448 }
449 if (nargs < 1) {
450 goto skip_optional;
451 }
452 ls = args[0];
453 if (nargs < 2) {
454 goto skip_optional;
455 }
456 rs = args[1];
457 if (nargs < 3) {
458 goto skip_optional;
459 }
460 ts = args[2];
461 if (nargs < 4) {
462 goto skip_optional;
463 }
464 bs = args[3];
465 if (nargs < 5) {
466 goto skip_optional;
467 }
468 tl = args[4];
469 if (nargs < 6) {
470 goto skip_optional;
471 }
472 tr = args[5];
473 if (nargs < 7) {
474 goto skip_optional;
475 }
476 bl = args[6];
477 if (nargs < 8) {
478 goto skip_optional;
479 }
480 br = args[7];
481skip_optional:
482 return_value = _curses_window_border_impl(self, ls, rs, ts, bs, tl, tr, bl, br);
483
484exit:
485 return return_value;
486}
487
488PyDoc_STRVAR(_curses_window_box__doc__,
489"box([verch=0, horch=0])\n"
490"Draw a border around the edges of the window.\n"
491"\n"
492" verch\n"
493" Left and right side.\n"
494" horch\n"
495" Top and bottom side.\n"
496"\n"
497"Similar to border(), but both ls and rs are verch and both ts and bs are\n"
498"horch. The default corner characters are always used by this function.");
499
500#define _CURSES_WINDOW_BOX_METHODDEF \
501 {"box", (PyCFunction)_curses_window_box, METH_VARARGS, _curses_window_box__doc__},
502
503static PyObject *
504_curses_window_box_impl(PyCursesWindowObject *self, int group_right_1,
505 PyObject *verch, PyObject *horch);
506
507static PyObject *
508_curses_window_box(PyCursesWindowObject *self, PyObject *args)
509{
510 PyObject *return_value = NULL;
511 int group_right_1 = 0;
512 PyObject *verch = _PyLong_GetZero();
513 PyObject *horch = _PyLong_GetZero();
514
515 switch (PyTuple_GET_SIZE(args)) {
516 case 0:
517 break;
518 case 2:
519 if (!PyArg_ParseTuple(args, "OO:box", &verch, &horch)) {
520 goto exit;
521 }
522 group_right_1 = 1;
523 break;
524 default:
525 PyErr_SetString(PyExc_TypeError, "_curses.window.box requires 0 to 2 arguments");
526 goto exit;
527 }
528 return_value = _curses_window_box_impl(self, group_right_1, verch, horch);
529
530exit:
531 return return_value;
532}
533
534PyDoc_STRVAR(_curses_window_delch__doc__,
535"delch([y, x])\n"
536"Delete any character at (y, x).\n"
537"\n"
538" y\n"
539" Y-coordinate.\n"
540" x\n"
541" X-coordinate.");
542
543#define _CURSES_WINDOW_DELCH_METHODDEF \
544 {"delch", (PyCFunction)_curses_window_delch, METH_VARARGS, _curses_window_delch__doc__},
545
546static PyObject *
547_curses_window_delch_impl(PyCursesWindowObject *self, int group_right_1,
548 int y, int x);
549
550static PyObject *
551_curses_window_delch(PyCursesWindowObject *self, PyObject *args)
552{
553 PyObject *return_value = NULL;
554 int group_right_1 = 0;
555 int y = 0;
556 int x = 0;
557
558 switch (PyTuple_GET_SIZE(args)) {
559 case 0:
560 break;
561 case 2:
562 if (!PyArg_ParseTuple(args, "ii:delch", &y, &x)) {
563 goto exit;
564 }
565 group_right_1 = 1;
566 break;
567 default:
568 PyErr_SetString(PyExc_TypeError, "_curses.window.delch requires 0 to 2 arguments");
569 goto exit;
570 }
571 return_value = _curses_window_delch_impl(self, group_right_1, y, x);
572
573exit:
574 return return_value;
575}
576
577PyDoc_STRVAR(_curses_window_derwin__doc__,
578"derwin([nlines=0, ncols=0,] begin_y, begin_x)\n"
579"Create a sub-window (window-relative coordinates).\n"
580"\n"
581" nlines\n"
582" Height.\n"
583" ncols\n"
584" Width.\n"
585" begin_y\n"
586" Top side y-coordinate.\n"
587" begin_x\n"
588" Left side x-coordinate.\n"
589"\n"
590"derwin() is the same as calling subwin(), except that begin_y and begin_x\n"
591"are relative to the origin of the window, rather than relative to the entire\n"
592"screen.");
593
594#define _CURSES_WINDOW_DERWIN_METHODDEF \
595 {"derwin", (PyCFunction)_curses_window_derwin, METH_VARARGS, _curses_window_derwin__doc__},
596
597static PyObject *
598_curses_window_derwin_impl(PyCursesWindowObject *self, int group_left_1,
599 int nlines, int ncols, int begin_y, int begin_x);
600
601static PyObject *
602_curses_window_derwin(PyCursesWindowObject *self, PyObject *args)
603{
604 PyObject *return_value = NULL;
605 int group_left_1 = 0;
606 int nlines = 0;
607 int ncols = 0;
608 int begin_y;
609 int begin_x;
610
611 switch (PyTuple_GET_SIZE(args)) {
612 case 2:
613 if (!PyArg_ParseTuple(args, "ii:derwin", &begin_y, &begin_x)) {
614 goto exit;
615 }
616 break;
617 case 4:
618 if (!PyArg_ParseTuple(args, "iiii:derwin", &nlines, &ncols, &begin_y, &begin_x)) {
619 goto exit;
620 }
621 group_left_1 = 1;
622 break;
623 default:
624 PyErr_SetString(PyExc_TypeError, "_curses.window.derwin requires 2 to 4 arguments");
625 goto exit;
626 }
627 return_value = _curses_window_derwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
628
629exit:
630 return return_value;
631}
632
633PyDoc_STRVAR(_curses_window_echochar__doc__,
634"echochar($self, ch, attr=_curses.A_NORMAL, /)\n"
635"--\n"
636"\n"
637"Add character ch with attribute attr, and refresh.\n"
638"\n"
639" ch\n"
640" Character to add.\n"
641" attr\n"
642" Attributes for the character.");
643
644#define _CURSES_WINDOW_ECHOCHAR_METHODDEF \
645 {"echochar", (PyCFunction)(void(*)(void))_curses_window_echochar, METH_FASTCALL, _curses_window_echochar__doc__},
646
647static PyObject *
648_curses_window_echochar_impl(PyCursesWindowObject *self, PyObject *ch,
649 long attr);
650
651static PyObject *
652_curses_window_echochar(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
653{
654 PyObject *return_value = NULL;
655 PyObject *ch;
656 long attr = A_NORMAL;
657
658 if (!_PyArg_CheckPositional("echochar", nargs, 1, 2)) {
659 goto exit;
660 }
661 ch = args[0];
662 if (nargs < 2) {
663 goto skip_optional;
664 }
665 attr = PyLong_AsLong(args[1]);
666 if (attr == -1 && PyErr_Occurred()) {
667 goto exit;
668 }
669skip_optional:
670 return_value = _curses_window_echochar_impl(self, ch, attr);
671
672exit:
673 return return_value;
674}
675
676#if defined(NCURSES_MOUSE_VERSION)
677
678PyDoc_STRVAR(_curses_window_enclose__doc__,
679"enclose($self, y, x, /)\n"
680"--\n"
681"\n"
682"Return True if the screen-relative coordinates are enclosed by the window.\n"
683"\n"
684" y\n"
685" Y-coordinate.\n"
686" x\n"
687" X-coordinate.");
688
689#define _CURSES_WINDOW_ENCLOSE_METHODDEF \
690 {"enclose", (PyCFunction)(void(*)(void))_curses_window_enclose, METH_FASTCALL, _curses_window_enclose__doc__},
691
692static PyObject *
693_curses_window_enclose_impl(PyCursesWindowObject *self, int y, int x);
694
695static PyObject *
696_curses_window_enclose(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
697{
698 PyObject *return_value = NULL;
699 int y;
700 int x;
701
702 if (!_PyArg_CheckPositional("enclose", nargs, 2, 2)) {
703 goto exit;
704 }
705 y = _PyLong_AsInt(args[0]);
706 if (y == -1 && PyErr_Occurred()) {
707 goto exit;
708 }
709 x = _PyLong_AsInt(args[1]);
710 if (x == -1 && PyErr_Occurred()) {
711 goto exit;
712 }
713 return_value = _curses_window_enclose_impl(self, y, x);
714
715exit:
716 return return_value;
717}
718
719#endif /* defined(NCURSES_MOUSE_VERSION) */
720
721PyDoc_STRVAR(_curses_window_getbkgd__doc__,
722"getbkgd($self, /)\n"
723"--\n"
724"\n"
725"Return the window\'s current background character/attribute pair.");
726
727#define _CURSES_WINDOW_GETBKGD_METHODDEF \
728 {"getbkgd", (PyCFunction)_curses_window_getbkgd, METH_NOARGS, _curses_window_getbkgd__doc__},
729
730static long
731_curses_window_getbkgd_impl(PyCursesWindowObject *self);
732
733static PyObject *
734_curses_window_getbkgd(PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored))
735{
736 PyObject *return_value = NULL;
737 long _return_value;
738
739 _return_value = _curses_window_getbkgd_impl(self);
740 if ((_return_value == -1) && PyErr_Occurred()) {
741 goto exit;
742 }
743 return_value = PyLong_FromLong(_return_value);
744
745exit:
746 return return_value;
747}
748
749PyDoc_STRVAR(_curses_window_getch__doc__,
750"getch([y, x])\n"
751"Get a character code from terminal keyboard.\n"
752"\n"
753" y\n"
754" Y-coordinate.\n"
755" x\n"
756" X-coordinate.\n"
757"\n"
758"The integer returned does not have to be in ASCII range: function keys,\n"
759"keypad keys and so on return numbers higher than 256. In no-delay mode, -1\n"
760"is returned if there is no input, else getch() waits until a key is pressed.");
761
762#define _CURSES_WINDOW_GETCH_METHODDEF \
763 {"getch", (PyCFunction)_curses_window_getch, METH_VARARGS, _curses_window_getch__doc__},
764
765static int
766_curses_window_getch_impl(PyCursesWindowObject *self, int group_right_1,
767 int y, int x);
768
769static PyObject *
770_curses_window_getch(PyCursesWindowObject *self, PyObject *args)
771{
772 PyObject *return_value = NULL;
773 int group_right_1 = 0;
774 int y = 0;
775 int x = 0;
776 int _return_value;
777
778 switch (PyTuple_GET_SIZE(args)) {
779 case 0:
780 break;
781 case 2:
782 if (!PyArg_ParseTuple(args, "ii:getch", &y, &x)) {
783 goto exit;
784 }
785 group_right_1 = 1;
786 break;
787 default:
788 PyErr_SetString(PyExc_TypeError, "_curses.window.getch requires 0 to 2 arguments");
789 goto exit;
790 }
791 _return_value = _curses_window_getch_impl(self, group_right_1, y, x);
792 if ((_return_value == -1) && PyErr_Occurred()) {
793 goto exit;
794 }
795 return_value = PyLong_FromLong((long)_return_value);
796
797exit:
798 return return_value;
799}
800
801PyDoc_STRVAR(_curses_window_getkey__doc__,
802"getkey([y, x])\n"
803"Get a character (string) from terminal keyboard.\n"
804"\n"
805" y\n"
806" Y-coordinate.\n"
807" x\n"
808" X-coordinate.\n"
809"\n"
810"Returning a string instead of an integer, as getch() does. Function keys,\n"
811"keypad keys and other special keys return a multibyte string containing the\n"
812"key name. In no-delay mode, an exception is raised if there is no input.");
813
814#define _CURSES_WINDOW_GETKEY_METHODDEF \
815 {"getkey", (PyCFunction)_curses_window_getkey, METH_VARARGS, _curses_window_getkey__doc__},
816
817static PyObject *
818_curses_window_getkey_impl(PyCursesWindowObject *self, int group_right_1,
819 int y, int x);
820
821static PyObject *
822_curses_window_getkey(PyCursesWindowObject *self, PyObject *args)
823{
824 PyObject *return_value = NULL;
825 int group_right_1 = 0;
826 int y = 0;
827 int x = 0;
828
829 switch (PyTuple_GET_SIZE(args)) {
830 case 0:
831 break;
832 case 2:
833 if (!PyArg_ParseTuple(args, "ii:getkey", &y, &x)) {
834 goto exit;
835 }
836 group_right_1 = 1;
837 break;
838 default:
839 PyErr_SetString(PyExc_TypeError, "_curses.window.getkey requires 0 to 2 arguments");
840 goto exit;
841 }
842 return_value = _curses_window_getkey_impl(self, group_right_1, y, x);
843
844exit:
845 return return_value;
846}
847
848#if defined(HAVE_NCURSESW)
849
850PyDoc_STRVAR(_curses_window_get_wch__doc__,
851"get_wch([y, x])\n"
852"Get a wide character from terminal keyboard.\n"
853"\n"
854" y\n"
855" Y-coordinate.\n"
856" x\n"
857" X-coordinate.\n"
858"\n"
859"Return a character for most keys, or an integer for function keys,\n"
860"keypad keys, and other special keys.");
861
862#define _CURSES_WINDOW_GET_WCH_METHODDEF \
863 {"get_wch", (PyCFunction)_curses_window_get_wch, METH_VARARGS, _curses_window_get_wch__doc__},
864
865static PyObject *
866_curses_window_get_wch_impl(PyCursesWindowObject *self, int group_right_1,
867 int y, int x);
868
869static PyObject *
870_curses_window_get_wch(PyCursesWindowObject *self, PyObject *args)
871{
872 PyObject *return_value = NULL;
873 int group_right_1 = 0;
874 int y = 0;
875 int x = 0;
876
877 switch (PyTuple_GET_SIZE(args)) {
878 case 0:
879 break;
880 case 2:
881 if (!PyArg_ParseTuple(args, "ii:get_wch", &y, &x)) {
882 goto exit;
883 }
884 group_right_1 = 1;
885 break;
886 default:
887 PyErr_SetString(PyExc_TypeError, "_curses.window.get_wch requires 0 to 2 arguments");
888 goto exit;
889 }
890 return_value = _curses_window_get_wch_impl(self, group_right_1, y, x);
891
892exit:
893 return return_value;
894}
895
896#endif /* defined(HAVE_NCURSESW) */
897
898PyDoc_STRVAR(_curses_window_hline__doc__,
899"hline([y, x,] ch, n, [attr=_curses.A_NORMAL])\n"
900"Display a horizontal line.\n"
901"\n"
902" y\n"
903" Starting Y-coordinate.\n"
904" x\n"
905" Starting X-coordinate.\n"
906" ch\n"
907" Character to draw.\n"
908" n\n"
909" Line length.\n"
910" attr\n"
911" Attributes for the characters.");
912
913#define _CURSES_WINDOW_HLINE_METHODDEF \
914 {"hline", (PyCFunction)_curses_window_hline, METH_VARARGS, _curses_window_hline__doc__},
915
916static PyObject *
917_curses_window_hline_impl(PyCursesWindowObject *self, int group_left_1,
918 int y, int x, PyObject *ch, int n,
919 int group_right_1, long attr);
920
921static PyObject *
922_curses_window_hline(PyCursesWindowObject *self, PyObject *args)
923{
924 PyObject *return_value = NULL;
925 int group_left_1 = 0;
926 int y = 0;
927 int x = 0;
928 PyObject *ch;
929 int n;
930 int group_right_1 = 0;
931 long attr = A_NORMAL;
932
933 switch (PyTuple_GET_SIZE(args)) {
934 case 2:
935 if (!PyArg_ParseTuple(args, "Oi:hline", &ch, &n)) {
936 goto exit;
937 }
938 break;
939 case 3:
940 if (!PyArg_ParseTuple(args, "Oil:hline", &ch, &n, &attr)) {
941 goto exit;
942 }
943 group_right_1 = 1;
944 break;
945 case 4:
946 if (!PyArg_ParseTuple(args, "iiOi:hline", &y, &x, &ch, &n)) {
947 goto exit;
948 }
949 group_left_1 = 1;
950 break;
951 case 5:
952 if (!PyArg_ParseTuple(args, "iiOil:hline", &y, &x, &ch, &n, &attr)) {
953 goto exit;
954 }
955 group_right_1 = 1;
956 group_left_1 = 1;
957 break;
958 default:
959 PyErr_SetString(PyExc_TypeError, "_curses.window.hline requires 2 to 5 arguments");
960 goto exit;
961 }
962 return_value = _curses_window_hline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
963
964exit:
965 return return_value;
966}
967
968PyDoc_STRVAR(_curses_window_insch__doc__,
969"insch([y, x,] ch, [attr=_curses.A_NORMAL])\n"
970"Insert a character before the current or specified position.\n"
971"\n"
972" y\n"
973" Y-coordinate.\n"
974" x\n"
975" X-coordinate.\n"
976" ch\n"
977" Character to insert.\n"
978" attr\n"
979" Attributes for the character.\n"
980"\n"
981"All characters to the right of the cursor are shifted one position right, with\n"
982"the rightmost characters on the line being lost.");
983
984#define _CURSES_WINDOW_INSCH_METHODDEF \
985 {"insch", (PyCFunction)_curses_window_insch, METH_VARARGS, _curses_window_insch__doc__},
986
987static PyObject *
988_curses_window_insch_impl(PyCursesWindowObject *self, int group_left_1,
989 int y, int x, PyObject *ch, int group_right_1,
990 long attr);
991
992static PyObject *
993_curses_window_insch(PyCursesWindowObject *self, PyObject *args)
994{
995 PyObject *return_value = NULL;
996 int group_left_1 = 0;
997 int y = 0;
998 int x = 0;
999 PyObject *ch;
1000 int group_right_1 = 0;
1001 long attr = A_NORMAL;
1002
1003 switch (PyTuple_GET_SIZE(args)) {
1004 case 1:
1005 if (!PyArg_ParseTuple(args, "O:insch", &ch)) {
1006 goto exit;
1007 }
1008 break;
1009 case 2:
1010 if (!PyArg_ParseTuple(args, "Ol:insch", &ch, &attr)) {
1011 goto exit;
1012 }
1013 group_right_1 = 1;
1014 break;
1015 case 3:
1016 if (!PyArg_ParseTuple(args, "iiO:insch", &y, &x, &ch)) {
1017 goto exit;
1018 }
1019 group_left_1 = 1;
1020 break;
1021 case 4:
1022 if (!PyArg_ParseTuple(args, "iiOl:insch", &y, &x, &ch, &attr)) {
1023 goto exit;
1024 }
1025 group_right_1 = 1;
1026 group_left_1 = 1;
1027 break;
1028 default:
1029 PyErr_SetString(PyExc_TypeError, "_curses.window.insch requires 1 to 4 arguments");
1030 goto exit;
1031 }
1032 return_value = _curses_window_insch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
1033
1034exit:
1035 return return_value;
1036}
1037
1038PyDoc_STRVAR(_curses_window_inch__doc__,
1039"inch([y, x])\n"
1040"Return the character at the given position in the window.\n"
1041"\n"
1042" y\n"
1043" Y-coordinate.\n"
1044" x\n"
1045" X-coordinate.\n"
1046"\n"
1047"The bottom 8 bits are the character proper, and upper bits are the attributes.");
1048
1049#define _CURSES_WINDOW_INCH_METHODDEF \
1050 {"inch", (PyCFunction)_curses_window_inch, METH_VARARGS, _curses_window_inch__doc__},
1051
1052static unsigned long
1053_curses_window_inch_impl(PyCursesWindowObject *self, int group_right_1,
1054 int y, int x);
1055
1056static PyObject *
1057_curses_window_inch(PyCursesWindowObject *self, PyObject *args)
1058{
1059 PyObject *return_value = NULL;
1060 int group_right_1 = 0;
1061 int y = 0;
1062 int x = 0;
1063 unsigned long _return_value;
1064
1065 switch (PyTuple_GET_SIZE(args)) {
1066 case 0:
1067 break;
1068 case 2:
1069 if (!PyArg_ParseTuple(args, "ii:inch", &y, &x)) {
1070 goto exit;
1071 }
1072 group_right_1 = 1;
1073 break;
1074 default:
1075 PyErr_SetString(PyExc_TypeError, "_curses.window.inch requires 0 to 2 arguments");
1076 goto exit;
1077 }
1078 _return_value = _curses_window_inch_impl(self, group_right_1, y, x);
1079 if ((_return_value == (unsigned long)-1) && PyErr_Occurred()) {
1080 goto exit;
1081 }
1082 return_value = PyLong_FromUnsignedLong(_return_value);
1083
1084exit:
1085 return return_value;
1086}
1087
1088PyDoc_STRVAR(_curses_window_insstr__doc__,
1089"insstr([y, x,] str, [attr])\n"
1090"Insert the string before the current or specified position.\n"
1091"\n"
1092" y\n"
1093" Y-coordinate.\n"
1094" x\n"
1095" X-coordinate.\n"
1096" str\n"
1097" String to insert.\n"
1098" attr\n"
1099" Attributes for characters.\n"
1100"\n"
1101"Insert a character string (as many characters as will fit on the line)\n"
1102"before the character under the cursor. All characters to the right of\n"
1103"the cursor are shifted right, with the rightmost characters on the line\n"
1104"being lost. The cursor position does not change (after moving to y, x,\n"
1105"if specified).");
1106
1107#define _CURSES_WINDOW_INSSTR_METHODDEF \
1108 {"insstr", (PyCFunction)_curses_window_insstr, METH_VARARGS, _curses_window_insstr__doc__},
1109
1110static PyObject *
1111_curses_window_insstr_impl(PyCursesWindowObject *self, int group_left_1,
1112 int y, int x, PyObject *str, int group_right_1,
1113 long attr);
1114
1115static PyObject *
1116_curses_window_insstr(PyCursesWindowObject *self, PyObject *args)
1117{
1118 PyObject *return_value = NULL;
1119 int group_left_1 = 0;
1120 int y = 0;
1121 int x = 0;
1122 PyObject *str;
1123 int group_right_1 = 0;
1124 long attr = 0;
1125
1126 switch (PyTuple_GET_SIZE(args)) {
1127 case 1:
1128 if (!PyArg_ParseTuple(args, "O:insstr", &str)) {
1129 goto exit;
1130 }
1131 break;
1132 case 2:
1133 if (!PyArg_ParseTuple(args, "Ol:insstr", &str, &attr)) {
1134 goto exit;
1135 }
1136 group_right_1 = 1;
1137 break;
1138 case 3:
1139 if (!PyArg_ParseTuple(args, "iiO:insstr", &y, &x, &str)) {
1140 goto exit;
1141 }
1142 group_left_1 = 1;
1143 break;
1144 case 4:
1145 if (!PyArg_ParseTuple(args, "iiOl:insstr", &y, &x, &str, &attr)) {
1146 goto exit;
1147 }
1148 group_right_1 = 1;
1149 group_left_1 = 1;
1150 break;
1151 default:
1152 PyErr_SetString(PyExc_TypeError, "_curses.window.insstr requires 1 to 4 arguments");
1153 goto exit;
1154 }
1155 return_value = _curses_window_insstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
1156
1157exit:
1158 return return_value;
1159}
1160
1161PyDoc_STRVAR(_curses_window_insnstr__doc__,
1162"insnstr([y, x,] str, n, [attr])\n"
1163"Insert at most n characters of the string.\n"
1164"\n"
1165" y\n"
1166" Y-coordinate.\n"
1167" x\n"
1168" X-coordinate.\n"
1169" str\n"
1170" String to insert.\n"
1171" n\n"
1172" Maximal number of characters.\n"
1173" attr\n"
1174" Attributes for characters.\n"
1175"\n"
1176"Insert a character string (as many characters as will fit on the line)\n"
1177"before the character under the cursor, up to n characters. If n is zero\n"
1178"or negative, the entire string is inserted. All characters to the right\n"
1179"of the cursor are shifted right, with the rightmost characters on the line\n"
1180"being lost. The cursor position does not change (after moving to y, x, if\n"
1181"specified).");
1182
1183#define _CURSES_WINDOW_INSNSTR_METHODDEF \
1184 {"insnstr", (PyCFunction)_curses_window_insnstr, METH_VARARGS, _curses_window_insnstr__doc__},
1185
1186static PyObject *
1187_curses_window_insnstr_impl(PyCursesWindowObject *self, int group_left_1,
1188 int y, int x, PyObject *str, int n,
1189 int group_right_1, long attr);
1190
1191static PyObject *
1192_curses_window_insnstr(PyCursesWindowObject *self, PyObject *args)
1193{
1194 PyObject *return_value = NULL;
1195 int group_left_1 = 0;
1196 int y = 0;
1197 int x = 0;
1198 PyObject *str;
1199 int n;
1200 int group_right_1 = 0;
1201 long attr = 0;
1202
1203 switch (PyTuple_GET_SIZE(args)) {
1204 case 2:
1205 if (!PyArg_ParseTuple(args, "Oi:insnstr", &str, &n)) {
1206 goto exit;
1207 }
1208 break;
1209 case 3:
1210 if (!PyArg_ParseTuple(args, "Oil:insnstr", &str, &n, &attr)) {
1211 goto exit;
1212 }
1213 group_right_1 = 1;
1214 break;
1215 case 4:
1216 if (!PyArg_ParseTuple(args, "iiOi:insnstr", &y, &x, &str, &n)) {
1217 goto exit;
1218 }
1219 group_left_1 = 1;
1220 break;
1221 case 5:
1222 if (!PyArg_ParseTuple(args, "iiOil:insnstr", &y, &x, &str, &n, &attr)) {
1223 goto exit;
1224 }
1225 group_right_1 = 1;
1226 group_left_1 = 1;
1227 break;
1228 default:
1229 PyErr_SetString(PyExc_TypeError, "_curses.window.insnstr requires 2 to 5 arguments");
1230 goto exit;
1231 }
1232 return_value = _curses_window_insnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
1233
1234exit:
1235 return return_value;
1236}
1237
1238PyDoc_STRVAR(_curses_window_is_linetouched__doc__,
1239"is_linetouched($self, line, /)\n"
1240"--\n"
1241"\n"
1242"Return True if the specified line was modified, otherwise return False.\n"
1243"\n"
1244" line\n"
1245" Line number.\n"
1246"\n"
1247"Raise a curses.error exception if line is not valid for the given window.");
1248
1249#define _CURSES_WINDOW_IS_LINETOUCHED_METHODDEF \
1250 {"is_linetouched", (PyCFunction)_curses_window_is_linetouched, METH_O, _curses_window_is_linetouched__doc__},
1251
1252static PyObject *
1253_curses_window_is_linetouched_impl(PyCursesWindowObject *self, int line);
1254
1255static PyObject *
1256_curses_window_is_linetouched(PyCursesWindowObject *self, PyObject *arg)
1257{
1258 PyObject *return_value = NULL;
1259 int line;
1260
1261 line = _PyLong_AsInt(arg);
1262 if (line == -1 && PyErr_Occurred()) {
1263 goto exit;
1264 }
1265 return_value = _curses_window_is_linetouched_impl(self, line);
1266
1267exit:
1268 return return_value;
1269}
1270
1271#if defined(py_is_pad)
1272
1273PyDoc_STRVAR(_curses_window_noutrefresh__doc__,
1274"noutrefresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\n"
1275"Mark for refresh but wait.\n"
1276"\n"
1277"This function updates the data structure representing the desired state of the\n"
1278"window, but does not force an update of the physical screen. To accomplish\n"
1279"that, call doupdate().");
1280
1281#define _CURSES_WINDOW_NOUTREFRESH_METHODDEF \
1282 {"noutrefresh", (PyCFunction)_curses_window_noutrefresh, METH_VARARGS, _curses_window_noutrefresh__doc__},
1283
1284static PyObject *
1285_curses_window_noutrefresh_impl(PyCursesWindowObject *self,
1286 int group_right_1, int pminrow, int pmincol,
1287 int sminrow, int smincol, int smaxrow,
1288 int smaxcol);
1289
1290static PyObject *
1291_curses_window_noutrefresh(PyCursesWindowObject *self, PyObject *args)
1292{
1293 PyObject *return_value = NULL;
1294 int group_right_1 = 0;
1295 int pminrow = 0;
1296 int pmincol = 0;
1297 int sminrow = 0;
1298 int smincol = 0;
1299 int smaxrow = 0;
1300 int smaxcol = 0;
1301
1302 switch (PyTuple_GET_SIZE(args)) {
1303 case 0:
1304 break;
1305 case 6:
1306 if (!PyArg_ParseTuple(args, "iiiiii:noutrefresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
1307 goto exit;
1308 }
1309 group_right_1 = 1;
1310 break;
1311 default:
1312 PyErr_SetString(PyExc_TypeError, "_curses.window.noutrefresh requires 0 to 6 arguments");
1313 goto exit;
1314 }
1315 return_value = _curses_window_noutrefresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
1316
1317exit:
1318 return return_value;
1319}
1320
1321#endif /* defined(py_is_pad) */
1322
1323#if !defined(py_is_pad)
1324
1325PyDoc_STRVAR(_curses_window_noutrefresh__doc__,
1326"noutrefresh($self, /)\n"
1327"--\n"
1328"\n"
1329"Mark for refresh but wait.\n"
1330"\n"
1331"This function updates the data structure representing the desired state of the\n"
1332"window, but does not force an update of the physical screen. To accomplish\n"
1333"that, call doupdate().");
1334
1335#define _CURSES_WINDOW_NOUTREFRESH_METHODDEF \
1336 {"noutrefresh", (PyCFunction)_curses_window_noutrefresh, METH_NOARGS, _curses_window_noutrefresh__doc__},
1337
1338static PyObject *
1339_curses_window_noutrefresh_impl(PyCursesWindowObject *self);
1340
1341static PyObject *
1342_curses_window_noutrefresh(PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored))
1343{
1344 return _curses_window_noutrefresh_impl(self);
1345}
1346
1347#endif /* !defined(py_is_pad) */
1348
1349PyDoc_STRVAR(_curses_window_overlay__doc__,
1350"overlay(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])\n"
1351"Overlay the window on top of destwin.\n"
1352"\n"
1353"The windows need not be the same size, only the overlapping region is copied.\n"
1354"This copy is non-destructive, which means that the current background\n"
1355"character does not overwrite the old contents of destwin.\n"
1356"\n"
1357"To get fine-grained control over the copied region, the second form of\n"
1358"overlay() can be used. sminrow and smincol are the upper-left coordinates\n"
1359"of the source window, and the other variables mark a rectangle in the\n"
1360"destination window.");
1361
1362#define _CURSES_WINDOW_OVERLAY_METHODDEF \
1363 {"overlay", (PyCFunction)_curses_window_overlay, METH_VARARGS, _curses_window_overlay__doc__},
1364
1365static PyObject *
1366_curses_window_overlay_impl(PyCursesWindowObject *self,
1367 PyCursesWindowObject *destwin, int group_right_1,
1368 int sminrow, int smincol, int dminrow,
1369 int dmincol, int dmaxrow, int dmaxcol);
1370
1371static PyObject *
1372_curses_window_overlay(PyCursesWindowObject *self, PyObject *args)
1373{
1374 PyObject *return_value = NULL;
1375 PyCursesWindowObject *destwin;
1376 int group_right_1 = 0;
1377 int sminrow = 0;
1378 int smincol = 0;
1379 int dminrow = 0;
1380 int dmincol = 0;
1381 int dmaxrow = 0;
1382 int dmaxcol = 0;
1383
1384 switch (PyTuple_GET_SIZE(args)) {
1385 case 1:
1386 if (!PyArg_ParseTuple(args, "O!:overlay", &PyCursesWindow_Type, &destwin)) {
1387 goto exit;
1388 }
1389 break;
1390 case 7:
1391 if (!PyArg_ParseTuple(args, "O!iiiiii:overlay", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
1392 goto exit;
1393 }
1394 group_right_1 = 1;
1395 break;
1396 default:
1397 PyErr_SetString(PyExc_TypeError, "_curses.window.overlay requires 1 to 7 arguments");
1398 goto exit;
1399 }
1400 return_value = _curses_window_overlay_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
1401
1402exit:
1403 return return_value;
1404}
1405
1406PyDoc_STRVAR(_curses_window_overwrite__doc__,
1407"overwrite(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow,\n"
1408" dmaxcol])\n"
1409"Overwrite the window on top of destwin.\n"
1410"\n"
1411"The windows need not be the same size, in which case only the overlapping\n"
1412"region is copied. This copy is destructive, which means that the current\n"
1413"background character overwrites the old contents of destwin.\n"
1414"\n"
1415"To get fine-grained control over the copied region, the second form of\n"
1416"overwrite() can be used. sminrow and smincol are the upper-left coordinates\n"
1417"of the source window, the other variables mark a rectangle in the destination\n"
1418"window.");
1419
1420#define _CURSES_WINDOW_OVERWRITE_METHODDEF \
1421 {"overwrite", (PyCFunction)_curses_window_overwrite, METH_VARARGS, _curses_window_overwrite__doc__},
1422
1423static PyObject *
1424_curses_window_overwrite_impl(PyCursesWindowObject *self,
1425 PyCursesWindowObject *destwin,
1426 int group_right_1, int sminrow, int smincol,
1427 int dminrow, int dmincol, int dmaxrow,
1428 int dmaxcol);
1429
1430static PyObject *
1431_curses_window_overwrite(PyCursesWindowObject *self, PyObject *args)
1432{
1433 PyObject *return_value = NULL;
1434 PyCursesWindowObject *destwin;
1435 int group_right_1 = 0;
1436 int sminrow = 0;
1437 int smincol = 0;
1438 int dminrow = 0;
1439 int dmincol = 0;
1440 int dmaxrow = 0;
1441 int dmaxcol = 0;
1442
1443 switch (PyTuple_GET_SIZE(args)) {
1444 case 1:
1445 if (!PyArg_ParseTuple(args, "O!:overwrite", &PyCursesWindow_Type, &destwin)) {
1446 goto exit;
1447 }
1448 break;
1449 case 7:
1450 if (!PyArg_ParseTuple(args, "O!iiiiii:overwrite", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
1451 goto exit;
1452 }
1453 group_right_1 = 1;
1454 break;
1455 default:
1456 PyErr_SetString(PyExc_TypeError, "_curses.window.overwrite requires 1 to 7 arguments");
1457 goto exit;
1458 }
1459 return_value = _curses_window_overwrite_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
1460
1461exit:
1462 return return_value;
1463}
1464
1465PyDoc_STRVAR(_curses_window_putwin__doc__,
1466"putwin($self, file, /)\n"
1467"--\n"
1468"\n"
1469"Write all data associated with the window into the provided file object.\n"
1470"\n"
1471"This information can be later retrieved using the getwin() function.");
1472
1473#define _CURSES_WINDOW_PUTWIN_METHODDEF \
1474 {"putwin", (PyCFunction)_curses_window_putwin, METH_O, _curses_window_putwin__doc__},
1475
1476PyDoc_STRVAR(_curses_window_redrawln__doc__,
1477"redrawln($self, beg, num, /)\n"
1478"--\n"
1479"\n"
1480"Mark the specified lines corrupted.\n"
1481"\n"
1482" beg\n"
1483" Starting line number.\n"
1484" num\n"
1485" The number of lines.\n"
1486"\n"
1487"They should be completely redrawn on the next refresh() call.");
1488
1489#define _CURSES_WINDOW_REDRAWLN_METHODDEF \
1490 {"redrawln", (PyCFunction)(void(*)(void))_curses_window_redrawln, METH_FASTCALL, _curses_window_redrawln__doc__},
1491
1492static PyObject *
1493_curses_window_redrawln_impl(PyCursesWindowObject *self, int beg, int num);
1494
1495static PyObject *
1496_curses_window_redrawln(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
1497{
1498 PyObject *return_value = NULL;
1499 int beg;
1500 int num;
1501
1502 if (!_PyArg_CheckPositional("redrawln", nargs, 2, 2)) {
1503 goto exit;
1504 }
1505 beg = _PyLong_AsInt(args[0]);
1506 if (beg == -1 && PyErr_Occurred()) {
1507 goto exit;
1508 }
1509 num = _PyLong_AsInt(args[1]);
1510 if (num == -1 && PyErr_Occurred()) {
1511 goto exit;
1512 }
1513 return_value = _curses_window_redrawln_impl(self, beg, num);
1514
1515exit:
1516 return return_value;
1517}
1518
1519PyDoc_STRVAR(_curses_window_refresh__doc__,
1520"refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\n"
1521"Update the display immediately.\n"
1522"\n"
1523"Synchronize actual screen with previous drawing/deleting methods.\n"
1524"The 6 optional arguments can only be specified when the window is a pad\n"
1525"created with newpad(). The additional parameters are needed to indicate\n"
1526"what part of the pad and screen are involved. pminrow and pmincol specify\n"
1527"the upper left-hand corner of the rectangle to be displayed in the pad.\n"
1528"sminrow, smincol, smaxrow, and smaxcol specify the edges of the rectangle to\n"
1529"be displayed on the screen. The lower right-hand corner of the rectangle to\n"
1530"be displayed in the pad is calculated from the screen coordinates, since the\n"
1531"rectangles must be the same size. Both rectangles must be entirely contained\n"
1532"within their respective structures. Negative values of pminrow, pmincol,\n"
1533"sminrow, or smincol are treated as if they were zero.");
1534
1535#define _CURSES_WINDOW_REFRESH_METHODDEF \
1536 {"refresh", (PyCFunction)_curses_window_refresh, METH_VARARGS, _curses_window_refresh__doc__},
1537
1538static PyObject *
1539_curses_window_refresh_impl(PyCursesWindowObject *self, int group_right_1,
1540 int pminrow, int pmincol, int sminrow,
1541 int smincol, int smaxrow, int smaxcol);
1542
1543static PyObject *
1544_curses_window_refresh(PyCursesWindowObject *self, PyObject *args)
1545{
1546 PyObject *return_value = NULL;
1547 int group_right_1 = 0;
1548 int pminrow = 0;
1549 int pmincol = 0;
1550 int sminrow = 0;
1551 int smincol = 0;
1552 int smaxrow = 0;
1553 int smaxcol = 0;
1554
1555 switch (PyTuple_GET_SIZE(args)) {
1556 case 0:
1557 break;
1558 case 6:
1559 if (!PyArg_ParseTuple(args, "iiiiii:refresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
1560 goto exit;
1561 }
1562 group_right_1 = 1;
1563 break;
1564 default:
1565 PyErr_SetString(PyExc_TypeError, "_curses.window.refresh requires 0 to 6 arguments");
1566 goto exit;
1567 }
1568 return_value = _curses_window_refresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
1569
1570exit:
1571 return return_value;
1572}
1573
1574PyDoc_STRVAR(_curses_window_setscrreg__doc__,
1575"setscrreg($self, top, bottom, /)\n"
1576"--\n"
1577"\n"
1578"Define a software scrolling region.\n"
1579"\n"
1580" top\n"
1581" First line number.\n"
1582" bottom\n"
1583" Last line number.\n"
1584"\n"
1585"All scrolling actions will take place in this region.");
1586
1587#define _CURSES_WINDOW_SETSCRREG_METHODDEF \
1588 {"setscrreg", (PyCFunction)(void(*)(void))_curses_window_setscrreg, METH_FASTCALL, _curses_window_setscrreg__doc__},
1589
1590static PyObject *
1591_curses_window_setscrreg_impl(PyCursesWindowObject *self, int top,
1592 int bottom);
1593
1594static PyObject *
1595_curses_window_setscrreg(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
1596{
1597 PyObject *return_value = NULL;
1598 int top;
1599 int bottom;
1600
1601 if (!_PyArg_CheckPositional("setscrreg", nargs, 2, 2)) {
1602 goto exit;
1603 }
1604 top = _PyLong_AsInt(args[0]);
1605 if (top == -1 && PyErr_Occurred()) {
1606 goto exit;
1607 }
1608 bottom = _PyLong_AsInt(args[1]);
1609 if (bottom == -1 && PyErr_Occurred()) {
1610 goto exit;
1611 }
1612 return_value = _curses_window_setscrreg_impl(self, top, bottom);
1613
1614exit:
1615 return return_value;
1616}
1617
1618PyDoc_STRVAR(_curses_window_subwin__doc__,
1619"subwin([nlines=0, ncols=0,] begin_y, begin_x)\n"
1620"Create a sub-window (screen-relative coordinates).\n"
1621"\n"
1622" nlines\n"
1623" Height.\n"
1624" ncols\n"
1625" Width.\n"
1626" begin_y\n"
1627" Top side y-coordinate.\n"
1628" begin_x\n"
1629" Left side x-coordinate.\n"
1630"\n"
1631"By default, the sub-window will extend from the specified position to the\n"
1632"lower right corner of the window.");
1633
1634#define _CURSES_WINDOW_SUBWIN_METHODDEF \
1635 {"subwin", (PyCFunction)_curses_window_subwin, METH_VARARGS, _curses_window_subwin__doc__},
1636
1637static PyObject *
1638_curses_window_subwin_impl(PyCursesWindowObject *self, int group_left_1,
1639 int nlines, int ncols, int begin_y, int begin_x);
1640
1641static PyObject *
1642_curses_window_subwin(PyCursesWindowObject *self, PyObject *args)
1643{
1644 PyObject *return_value = NULL;
1645 int group_left_1 = 0;
1646 int nlines = 0;
1647 int ncols = 0;
1648 int begin_y;
1649 int begin_x;
1650
1651 switch (PyTuple_GET_SIZE(args)) {
1652 case 2:
1653 if (!PyArg_ParseTuple(args, "ii:subwin", &begin_y, &begin_x)) {
1654 goto exit;
1655 }
1656 break;
1657 case 4:
1658 if (!PyArg_ParseTuple(args, "iiii:subwin", &nlines, &ncols, &begin_y, &begin_x)) {
1659 goto exit;
1660 }
1661 group_left_1 = 1;
1662 break;
1663 default:
1664 PyErr_SetString(PyExc_TypeError, "_curses.window.subwin requires 2 to 4 arguments");
1665 goto exit;
1666 }
1667 return_value = _curses_window_subwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
1668
1669exit:
1670 return return_value;
1671}
1672
1673PyDoc_STRVAR(_curses_window_scroll__doc__,
1674"scroll([lines=1])\n"
1675"Scroll the screen or scrolling region.\n"
1676"\n"
1677" lines\n"
1678" Number of lines to scroll.\n"
1679"\n"
1680"Scroll upward if the argument is positive and downward if it is negative.");
1681
1682#define _CURSES_WINDOW_SCROLL_METHODDEF \
1683 {"scroll", (PyCFunction)_curses_window_scroll, METH_VARARGS, _curses_window_scroll__doc__},
1684
1685static PyObject *
1686_curses_window_scroll_impl(PyCursesWindowObject *self, int group_right_1,
1687 int lines);
1688
1689static PyObject *
1690_curses_window_scroll(PyCursesWindowObject *self, PyObject *args)
1691{
1692 PyObject *return_value = NULL;
1693 int group_right_1 = 0;
1694 int lines = 1;
1695
1696 switch (PyTuple_GET_SIZE(args)) {
1697 case 0:
1698 break;
1699 case 1:
1700 if (!PyArg_ParseTuple(args, "i:scroll", &lines)) {
1701 goto exit;
1702 }
1703 group_right_1 = 1;
1704 break;
1705 default:
1706 PyErr_SetString(PyExc_TypeError, "_curses.window.scroll requires 0 to 1 arguments");
1707 goto exit;
1708 }
1709 return_value = _curses_window_scroll_impl(self, group_right_1, lines);
1710
1711exit:
1712 return return_value;
1713}
1714
1715PyDoc_STRVAR(_curses_window_touchline__doc__,
1716"touchline(start, count, [changed=True])\n"
1717"Pretend count lines have been changed, starting with line start.\n"
1718"\n"
1719"If changed is supplied, it specifies whether the affected lines are marked\n"
1720"as having been changed (changed=True) or unchanged (changed=False).");
1721
1722#define _CURSES_WINDOW_TOUCHLINE_METHODDEF \
1723 {"touchline", (PyCFunction)_curses_window_touchline, METH_VARARGS, _curses_window_touchline__doc__},
1724
1725static PyObject *
1726_curses_window_touchline_impl(PyCursesWindowObject *self, int start,
1727 int count, int group_right_1, int changed);
1728
1729static PyObject *
1730_curses_window_touchline(PyCursesWindowObject *self, PyObject *args)
1731{
1732 PyObject *return_value = NULL;
1733 int start;
1734 int count;
1735 int group_right_1 = 0;
1736 int changed = 1;
1737
1738 switch (PyTuple_GET_SIZE(args)) {
1739 case 2:
1740 if (!PyArg_ParseTuple(args, "ii:touchline", &start, &count)) {
1741 goto exit;
1742 }
1743 break;
1744 case 3:
1745 if (!PyArg_ParseTuple(args, "iii:touchline", &start, &count, &changed)) {
1746 goto exit;
1747 }
1748 group_right_1 = 1;
1749 break;
1750 default:
1751 PyErr_SetString(PyExc_TypeError, "_curses.window.touchline requires 2 to 3 arguments");
1752 goto exit;
1753 }
1754 return_value = _curses_window_touchline_impl(self, start, count, group_right_1, changed);
1755
1756exit:
1757 return return_value;
1758}
1759
1760PyDoc_STRVAR(_curses_window_vline__doc__,
1761"vline([y, x,] ch, n, [attr=_curses.A_NORMAL])\n"
1762"Display a vertical line.\n"
1763"\n"
1764" y\n"
1765" Starting Y-coordinate.\n"
1766" x\n"
1767" Starting X-coordinate.\n"
1768" ch\n"
1769" Character to draw.\n"
1770" n\n"
1771" Line length.\n"
1772" attr\n"
1773" Attributes for the character.");
1774
1775#define _CURSES_WINDOW_VLINE_METHODDEF \
1776 {"vline", (PyCFunction)_curses_window_vline, METH_VARARGS, _curses_window_vline__doc__},
1777
1778static PyObject *
1779_curses_window_vline_impl(PyCursesWindowObject *self, int group_left_1,
1780 int y, int x, PyObject *ch, int n,
1781 int group_right_1, long attr);
1782
1783static PyObject *
1784_curses_window_vline(PyCursesWindowObject *self, PyObject *args)
1785{
1786 PyObject *return_value = NULL;
1787 int group_left_1 = 0;
1788 int y = 0;
1789 int x = 0;
1790 PyObject *ch;
1791 int n;
1792 int group_right_1 = 0;
1793 long attr = A_NORMAL;
1794
1795 switch (PyTuple_GET_SIZE(args)) {
1796 case 2:
1797 if (!PyArg_ParseTuple(args, "Oi:vline", &ch, &n)) {
1798 goto exit;
1799 }
1800 break;
1801 case 3:
1802 if (!PyArg_ParseTuple(args, "Oil:vline", &ch, &n, &attr)) {
1803 goto exit;
1804 }
1805 group_right_1 = 1;
1806 break;
1807 case 4:
1808 if (!PyArg_ParseTuple(args, "iiOi:vline", &y, &x, &ch, &n)) {
1809 goto exit;
1810 }
1811 group_left_1 = 1;
1812 break;
1813 case 5:
1814 if (!PyArg_ParseTuple(args, "iiOil:vline", &y, &x, &ch, &n, &attr)) {
1815 goto exit;
1816 }
1817 group_right_1 = 1;
1818 group_left_1 = 1;
1819 break;
1820 default:
1821 PyErr_SetString(PyExc_TypeError, "_curses.window.vline requires 2 to 5 arguments");
1822 goto exit;
1823 }
1824 return_value = _curses_window_vline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
1825
1826exit:
1827 return return_value;
1828}
1829
1830#if defined(HAVE_CURSES_FILTER)
1831
1832PyDoc_STRVAR(_curses_filter__doc__,
1833"filter($module, /)\n"
1834"--\n"
1835"\n");
1836
1837#define _CURSES_FILTER_METHODDEF \
1838 {"filter", (PyCFunction)_curses_filter, METH_NOARGS, _curses_filter__doc__},
1839
1840static PyObject *
1841_curses_filter_impl(PyObject *module);
1842
1843static PyObject *
1844_curses_filter(PyObject *module, PyObject *Py_UNUSED(ignored))
1845{
1846 return _curses_filter_impl(module);
1847}
1848
1849#endif /* defined(HAVE_CURSES_FILTER) */
1850
1851PyDoc_STRVAR(_curses_baudrate__doc__,
1852"baudrate($module, /)\n"
1853"--\n"
1854"\n"
1855"Return the output speed of the terminal in bits per second.");
1856
1857#define _CURSES_BAUDRATE_METHODDEF \
1858 {"baudrate", (PyCFunction)_curses_baudrate, METH_NOARGS, _curses_baudrate__doc__},
1859
1860static PyObject *
1861_curses_baudrate_impl(PyObject *module);
1862
1863static PyObject *
1864_curses_baudrate(PyObject *module, PyObject *Py_UNUSED(ignored))
1865{
1866 return _curses_baudrate_impl(module);
1867}
1868
1869PyDoc_STRVAR(_curses_beep__doc__,
1870"beep($module, /)\n"
1871"--\n"
1872"\n"
1873"Emit a short attention sound.");
1874
1875#define _CURSES_BEEP_METHODDEF \
1876 {"beep", (PyCFunction)_curses_beep, METH_NOARGS, _curses_beep__doc__},
1877
1878static PyObject *
1879_curses_beep_impl(PyObject *module);
1880
1881static PyObject *
1882_curses_beep(PyObject *module, PyObject *Py_UNUSED(ignored))
1883{
1884 return _curses_beep_impl(module);
1885}
1886
1887PyDoc_STRVAR(_curses_can_change_color__doc__,
1888"can_change_color($module, /)\n"
1889"--\n"
1890"\n"
1891"Return True if the programmer can change the colors displayed by the terminal.");
1892
1893#define _CURSES_CAN_CHANGE_COLOR_METHODDEF \
1894 {"can_change_color", (PyCFunction)_curses_can_change_color, METH_NOARGS, _curses_can_change_color__doc__},
1895
1896static PyObject *
1897_curses_can_change_color_impl(PyObject *module);
1898
1899static PyObject *
1900_curses_can_change_color(PyObject *module, PyObject *Py_UNUSED(ignored))
1901{
1902 return _curses_can_change_color_impl(module);
1903}
1904
1905PyDoc_STRVAR(_curses_cbreak__doc__,
1906"cbreak($module, flag=True, /)\n"
1907"--\n"
1908"\n"
1909"Enter cbreak mode.\n"
1910"\n"
1911" flag\n"
1912" If false, the effect is the same as calling nocbreak().\n"
1913"\n"
1914"In cbreak mode (sometimes called \"rare\" mode) normal tty line buffering is\n"
1915"turned off and characters are available to be read one by one. However,\n"
1916"unlike raw mode, special characters (interrupt, quit, suspend, and flow\n"
1917"control) retain their effects on the tty driver and calling program.\n"
1918"Calling first raw() then cbreak() leaves the terminal in cbreak mode.");
1919
1920#define _CURSES_CBREAK_METHODDEF \
1921 {"cbreak", (PyCFunction)(void(*)(void))_curses_cbreak, METH_FASTCALL, _curses_cbreak__doc__},
1922
1923static PyObject *
1924_curses_cbreak_impl(PyObject *module, int flag);
1925
1926static PyObject *
1927_curses_cbreak(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1928{
1929 PyObject *return_value = NULL;
1930 int flag = 1;
1931
1932 if (!_PyArg_CheckPositional("cbreak", nargs, 0, 1)) {
1933 goto exit;
1934 }
1935 if (nargs < 1) {
1936 goto skip_optional;
1937 }
1938 flag = _PyLong_AsInt(args[0]);
1939 if (flag == -1 && PyErr_Occurred()) {
1940 goto exit;
1941 }
1942skip_optional:
1943 return_value = _curses_cbreak_impl(module, flag);
1944
1945exit:
1946 return return_value;
1947}
1948
1949PyDoc_STRVAR(_curses_color_content__doc__,
1950"color_content($module, color_number, /)\n"
1951"--\n"
1952"\n"
1953"Return the red, green, and blue (RGB) components of the specified color.\n"
1954"\n"
1955" color_number\n"
1956" The number of the color (0 - (COLORS-1)).\n"
1957"\n"
1958"A 3-tuple is returned, containing the R, G, B values for the given color,\n"
1959"which will be between 0 (no component) and 1000 (maximum amount of component).");
1960
1961#define _CURSES_COLOR_CONTENT_METHODDEF \
1962 {"color_content", (PyCFunction)_curses_color_content, METH_O, _curses_color_content__doc__},
1963
1964static PyObject *
1965_curses_color_content_impl(PyObject *module, int color_number);
1966
1967static PyObject *
1968_curses_color_content(PyObject *module, PyObject *arg)
1969{
1970 PyObject *return_value = NULL;
1971 int color_number;
1972
1973 if (!color_converter(arg, &color_number)) {
1974 goto exit;
1975 }
1976 return_value = _curses_color_content_impl(module, color_number);
1977
1978exit:
1979 return return_value;
1980}
1981
1982PyDoc_STRVAR(_curses_color_pair__doc__,
1983"color_pair($module, pair_number, /)\n"
1984"--\n"
1985"\n"
1986"Return the attribute value for displaying text in the specified color.\n"
1987"\n"
1988" pair_number\n"
1989" The number of the color pair.\n"
1990"\n"
1991"This attribute value can be combined with A_STANDOUT, A_REVERSE, and the\n"
1992"other A_* attributes. pair_number() is the counterpart to this function.");
1993
1994#define _CURSES_COLOR_PAIR_METHODDEF \
1995 {"color_pair", (PyCFunction)_curses_color_pair, METH_O, _curses_color_pair__doc__},
1996
1997static PyObject *
1998_curses_color_pair_impl(PyObject *module, int pair_number);
1999
2000static PyObject *
2001_curses_color_pair(PyObject *module, PyObject *arg)
2002{
2003 PyObject *return_value = NULL;
2004 int pair_number;
2005
2006 pair_number = _PyLong_AsInt(arg);
2007 if (pair_number == -1 && PyErr_Occurred()) {
2008 goto exit;
2009 }
2010 return_value = _curses_color_pair_impl(module, pair_number);
2011
2012exit:
2013 return return_value;
2014}
2015
2016PyDoc_STRVAR(_curses_curs_set__doc__,
2017"curs_set($module, visibility, /)\n"
2018"--\n"
2019"\n"
2020"Set the cursor state.\n"
2021"\n"
2022" visibility\n"
2023" 0 for invisible, 1 for normal visible, or 2 for very visible.\n"
2024"\n"
2025"If the terminal supports the visibility requested, the previous cursor\n"
2026"state is returned; otherwise, an exception is raised. On many terminals,\n"
2027"the \"visible\" mode is an underline cursor and the \"very visible\" mode is\n"
2028"a block cursor.");
2029
2030#define _CURSES_CURS_SET_METHODDEF \
2031 {"curs_set", (PyCFunction)_curses_curs_set, METH_O, _curses_curs_set__doc__},
2032
2033static PyObject *
2034_curses_curs_set_impl(PyObject *module, int visibility);
2035
2036static PyObject *
2037_curses_curs_set(PyObject *module, PyObject *arg)
2038{
2039 PyObject *return_value = NULL;
2040 int visibility;
2041
2042 visibility = _PyLong_AsInt(arg);
2043 if (visibility == -1 && PyErr_Occurred()) {
2044 goto exit;
2045 }
2046 return_value = _curses_curs_set_impl(module, visibility);
2047
2048exit:
2049 return return_value;
2050}
2051
2052PyDoc_STRVAR(_curses_def_prog_mode__doc__,
2053"def_prog_mode($module, /)\n"
2054"--\n"
2055"\n"
2056"Save the current terminal mode as the \"program\" mode.\n"
2057"\n"
2058"The \"program\" mode is the mode when the running program is using curses.\n"
2059"\n"
2060"Subsequent calls to reset_prog_mode() will restore this mode.");
2061
2062#define _CURSES_DEF_PROG_MODE_METHODDEF \
2063 {"def_prog_mode", (PyCFunction)_curses_def_prog_mode, METH_NOARGS, _curses_def_prog_mode__doc__},
2064
2065static PyObject *
2066_curses_def_prog_mode_impl(PyObject *module);
2067
2068static PyObject *
2069_curses_def_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
2070{
2071 return _curses_def_prog_mode_impl(module);
2072}
2073
2074PyDoc_STRVAR(_curses_def_shell_mode__doc__,
2075"def_shell_mode($module, /)\n"
2076"--\n"
2077"\n"
2078"Save the current terminal mode as the \"shell\" mode.\n"
2079"\n"
2080"The \"shell\" mode is the mode when the running program is not using curses.\n"
2081"\n"
2082"Subsequent calls to reset_shell_mode() will restore this mode.");
2083
2084#define _CURSES_DEF_SHELL_MODE_METHODDEF \
2085 {"def_shell_mode", (PyCFunction)_curses_def_shell_mode, METH_NOARGS, _curses_def_shell_mode__doc__},
2086
2087static PyObject *
2088_curses_def_shell_mode_impl(PyObject *module);
2089
2090static PyObject *
2091_curses_def_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
2092{
2093 return _curses_def_shell_mode_impl(module);
2094}
2095
2096PyDoc_STRVAR(_curses_delay_output__doc__,
2097"delay_output($module, ms, /)\n"
2098"--\n"
2099"\n"
2100"Insert a pause in output.\n"
2101"\n"
2102" ms\n"
2103" Duration in milliseconds.");
2104
2105#define _CURSES_DELAY_OUTPUT_METHODDEF \
2106 {"delay_output", (PyCFunction)_curses_delay_output, METH_O, _curses_delay_output__doc__},
2107
2108static PyObject *
2109_curses_delay_output_impl(PyObject *module, int ms);
2110
2111static PyObject *
2112_curses_delay_output(PyObject *module, PyObject *arg)
2113{
2114 PyObject *return_value = NULL;
2115 int ms;
2116
2117 ms = _PyLong_AsInt(arg);
2118 if (ms == -1 && PyErr_Occurred()) {
2119 goto exit;
2120 }
2121 return_value = _curses_delay_output_impl(module, ms);
2122
2123exit:
2124 return return_value;
2125}
2126
2127PyDoc_STRVAR(_curses_doupdate__doc__,
2128"doupdate($module, /)\n"
2129"--\n"
2130"\n"
2131"Update the physical screen to match the virtual screen.");
2132
2133#define _CURSES_DOUPDATE_METHODDEF \
2134 {"doupdate", (PyCFunction)_curses_doupdate, METH_NOARGS, _curses_doupdate__doc__},
2135
2136static PyObject *
2137_curses_doupdate_impl(PyObject *module);
2138
2139static PyObject *
2140_curses_doupdate(PyObject *module, PyObject *Py_UNUSED(ignored))
2141{
2142 return _curses_doupdate_impl(module);
2143}
2144
2145PyDoc_STRVAR(_curses_echo__doc__,
2146"echo($module, flag=True, /)\n"
2147"--\n"
2148"\n"
2149"Enter echo mode.\n"
2150"\n"
2151" flag\n"
2152" If false, the effect is the same as calling noecho().\n"
2153"\n"
2154"In echo mode, each character input is echoed to the screen as it is entered.");
2155
2156#define _CURSES_ECHO_METHODDEF \
2157 {"echo", (PyCFunction)(void(*)(void))_curses_echo, METH_FASTCALL, _curses_echo__doc__},
2158
2159static PyObject *
2160_curses_echo_impl(PyObject *module, int flag);
2161
2162static PyObject *
2163_curses_echo(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2164{
2165 PyObject *return_value = NULL;
2166 int flag = 1;
2167
2168 if (!_PyArg_CheckPositional("echo", nargs, 0, 1)) {
2169 goto exit;
2170 }
2171 if (nargs < 1) {
2172 goto skip_optional;
2173 }
2174 flag = _PyLong_AsInt(args[0]);
2175 if (flag == -1 && PyErr_Occurred()) {
2176 goto exit;
2177 }
2178skip_optional:
2179 return_value = _curses_echo_impl(module, flag);
2180
2181exit:
2182 return return_value;
2183}
2184
2185PyDoc_STRVAR(_curses_endwin__doc__,
2186"endwin($module, /)\n"
2187"--\n"
2188"\n"
2189"De-initialize the library, and return terminal to normal status.");
2190
2191#define _CURSES_ENDWIN_METHODDEF \
2192 {"endwin", (PyCFunction)_curses_endwin, METH_NOARGS, _curses_endwin__doc__},
2193
2194static PyObject *
2195_curses_endwin_impl(PyObject *module);
2196
2197static PyObject *
2198_curses_endwin(PyObject *module, PyObject *Py_UNUSED(ignored))
2199{
2200 return _curses_endwin_impl(module);
2201}
2202
2203PyDoc_STRVAR(_curses_erasechar__doc__,
2204"erasechar($module, /)\n"
2205"--\n"
2206"\n"
2207"Return the user\'s current erase character.");
2208
2209#define _CURSES_ERASECHAR_METHODDEF \
2210 {"erasechar", (PyCFunction)_curses_erasechar, METH_NOARGS, _curses_erasechar__doc__},
2211
2212static PyObject *
2213_curses_erasechar_impl(PyObject *module);
2214
2215static PyObject *
2216_curses_erasechar(PyObject *module, PyObject *Py_UNUSED(ignored))
2217{
2218 return _curses_erasechar_impl(module);
2219}
2220
2221PyDoc_STRVAR(_curses_flash__doc__,
2222"flash($module, /)\n"
2223"--\n"
2224"\n"
2225"Flash the screen.\n"
2226"\n"
2227"That is, change it to reverse-video and then change it back in a short interval.");
2228
2229#define _CURSES_FLASH_METHODDEF \
2230 {"flash", (PyCFunction)_curses_flash, METH_NOARGS, _curses_flash__doc__},
2231
2232static PyObject *
2233_curses_flash_impl(PyObject *module);
2234
2235static PyObject *
2236_curses_flash(PyObject *module, PyObject *Py_UNUSED(ignored))
2237{
2238 return _curses_flash_impl(module);
2239}
2240
2241PyDoc_STRVAR(_curses_flushinp__doc__,
2242"flushinp($module, /)\n"
2243"--\n"
2244"\n"
2245"Flush all input buffers.\n"
2246"\n"
2247"This throws away any typeahead that has been typed by the user and has not\n"
2248"yet been processed by the program.");
2249
2250#define _CURSES_FLUSHINP_METHODDEF \
2251 {"flushinp", (PyCFunction)_curses_flushinp, METH_NOARGS, _curses_flushinp__doc__},
2252
2253static PyObject *
2254_curses_flushinp_impl(PyObject *module);
2255
2256static PyObject *
2257_curses_flushinp(PyObject *module, PyObject *Py_UNUSED(ignored))
2258{
2259 return _curses_flushinp_impl(module);
2260}
2261
2262#if defined(getsyx)
2263
2264PyDoc_STRVAR(_curses_getsyx__doc__,
2265"getsyx($module, /)\n"
2266"--\n"
2267"\n"
2268"Return the current coordinates of the virtual screen cursor.\n"
2269"\n"
2270"Return a (y, x) tuple. If leaveok is currently true, return (-1, -1).");
2271
2272#define _CURSES_GETSYX_METHODDEF \
2273 {"getsyx", (PyCFunction)_curses_getsyx, METH_NOARGS, _curses_getsyx__doc__},
2274
2275static PyObject *
2276_curses_getsyx_impl(PyObject *module);
2277
2278static PyObject *
2279_curses_getsyx(PyObject *module, PyObject *Py_UNUSED(ignored))
2280{
2281 return _curses_getsyx_impl(module);
2282}
2283
2284#endif /* defined(getsyx) */
2285
2286#if defined(NCURSES_MOUSE_VERSION)
2287
2288PyDoc_STRVAR(_curses_getmouse__doc__,
2289"getmouse($module, /)\n"
2290"--\n"
2291"\n"
2292"Retrieve the queued mouse event.\n"
2293"\n"
2294"After getch() returns KEY_MOUSE to signal a mouse event, this function\n"
2295"returns a 5-tuple (id, x, y, z, bstate).");
2296
2297#define _CURSES_GETMOUSE_METHODDEF \
2298 {"getmouse", (PyCFunction)_curses_getmouse, METH_NOARGS, _curses_getmouse__doc__},
2299
2300static PyObject *
2301_curses_getmouse_impl(PyObject *module);
2302
2303static PyObject *
2304_curses_getmouse(PyObject *module, PyObject *Py_UNUSED(ignored))
2305{
2306 return _curses_getmouse_impl(module);
2307}
2308
2309#endif /* defined(NCURSES_MOUSE_VERSION) */
2310
2311#if defined(NCURSES_MOUSE_VERSION)
2312
2313PyDoc_STRVAR(_curses_ungetmouse__doc__,
2314"ungetmouse($module, id, x, y, z, bstate, /)\n"
2315"--\n"
2316"\n"
2317"Push a KEY_MOUSE event onto the input queue.\n"
2318"\n"
2319"The following getmouse() will return the given state data.");
2320
2321#define _CURSES_UNGETMOUSE_METHODDEF \
2322 {"ungetmouse", (PyCFunction)(void(*)(void))_curses_ungetmouse, METH_FASTCALL, _curses_ungetmouse__doc__},
2323
2324static PyObject *
2325_curses_ungetmouse_impl(PyObject *module, short id, int x, int y, int z,
2326 unsigned long bstate);
2327
2328static PyObject *
2329_curses_ungetmouse(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2330{
2331 PyObject *return_value = NULL;
2332 short id;
2333 int x;
2334 int y;
2335 int z;
2336 unsigned long bstate;
2337
2338 if (!_PyArg_CheckPositional("ungetmouse", nargs, 5, 5)) {
2339 goto exit;
2340 }
2341 {
2342 long ival = PyLong_AsLong(args[0]);
2343 if (ival == -1 && PyErr_Occurred()) {
2344 goto exit;
2345 }
2346 else if (ival < SHRT_MIN) {
2347 PyErr_SetString(PyExc_OverflowError,
2348 "signed short integer is less than minimum");
2349 goto exit;
2350 }
2351 else if (ival > SHRT_MAX) {
2352 PyErr_SetString(PyExc_OverflowError,
2353 "signed short integer is greater than maximum");
2354 goto exit;
2355 }
2356 else {
2357 id = (short) ival;
2358 }
2359 }
2360 x = _PyLong_AsInt(args[1]);
2361 if (x == -1 && PyErr_Occurred()) {
2362 goto exit;
2363 }
2364 y = _PyLong_AsInt(args[2]);
2365 if (y == -1 && PyErr_Occurred()) {
2366 goto exit;
2367 }
2368 z = _PyLong_AsInt(args[3]);
2369 if (z == -1 && PyErr_Occurred()) {
2370 goto exit;
2371 }
2372 if (!PyLong_Check(args[4])) {
2373 _PyArg_BadArgument("ungetmouse", "argument 5", "int", args[4]);
2374 goto exit;
2375 }
2376 bstate = PyLong_AsUnsignedLongMask(args[4]);
2377 return_value = _curses_ungetmouse_impl(module, id, x, y, z, bstate);
2378
2379exit:
2380 return return_value;
2381}
2382
2383#endif /* defined(NCURSES_MOUSE_VERSION) */
2384
2385PyDoc_STRVAR(_curses_getwin__doc__,
2386"getwin($module, file, /)\n"
2387"--\n"
2388"\n"
2389"Read window related data stored in the file by an earlier putwin() call.\n"
2390"\n"
2391"The routine then creates and initializes a new window using that data,\n"
2392"returning the new window object.");
2393
2394#define _CURSES_GETWIN_METHODDEF \
2395 {"getwin", (PyCFunction)_curses_getwin, METH_O, _curses_getwin__doc__},
2396
2397PyDoc_STRVAR(_curses_halfdelay__doc__,
2398"halfdelay($module, tenths, /)\n"
2399"--\n"
2400"\n"
2401"Enter half-delay mode.\n"
2402"\n"
2403" tenths\n"
2404" Maximal blocking delay in tenths of seconds (1 - 255).\n"
2405"\n"
2406"Use nocbreak() to leave half-delay mode.");
2407
2408#define _CURSES_HALFDELAY_METHODDEF \
2409 {"halfdelay", (PyCFunction)_curses_halfdelay, METH_O, _curses_halfdelay__doc__},
2410
2411static PyObject *
2412_curses_halfdelay_impl(PyObject *module, unsigned char tenths);
2413
2414static PyObject *
2415_curses_halfdelay(PyObject *module, PyObject *arg)
2416{
2417 PyObject *return_value = NULL;
2418 unsigned char tenths;
2419
2420 {
2421 long ival = PyLong_AsLong(arg);
2422 if (ival == -1 && PyErr_Occurred()) {
2423 goto exit;
2424 }
2425 else if (ival < 0) {
2426 PyErr_SetString(PyExc_OverflowError,
2427 "unsigned byte integer is less than minimum");
2428 goto exit;
2429 }
2430 else if (ival > UCHAR_MAX) {
2431 PyErr_SetString(PyExc_OverflowError,
2432 "unsigned byte integer is greater than maximum");
2433 goto exit;
2434 }
2435 else {
2436 tenths = (unsigned char) ival;
2437 }
2438 }
2439 return_value = _curses_halfdelay_impl(module, tenths);
2440
2441exit:
2442 return return_value;
2443}
2444
2445PyDoc_STRVAR(_curses_has_colors__doc__,
2446"has_colors($module, /)\n"
2447"--\n"
2448"\n"
2449"Return True if the terminal can display colors; otherwise, return False.");
2450
2451#define _CURSES_HAS_COLORS_METHODDEF \
2452 {"has_colors", (PyCFunction)_curses_has_colors, METH_NOARGS, _curses_has_colors__doc__},
2453
2454static PyObject *
2455_curses_has_colors_impl(PyObject *module);
2456
2457static PyObject *
2458_curses_has_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
2459{
2460 return _curses_has_colors_impl(module);
2461}
2462
2463PyDoc_STRVAR(_curses_has_ic__doc__,
2464"has_ic($module, /)\n"
2465"--\n"
2466"\n"
2467"Return True if the terminal has insert- and delete-character capabilities.");
2468
2469#define _CURSES_HAS_IC_METHODDEF \
2470 {"has_ic", (PyCFunction)_curses_has_ic, METH_NOARGS, _curses_has_ic__doc__},
2471
2472static PyObject *
2473_curses_has_ic_impl(PyObject *module);
2474
2475static PyObject *
2476_curses_has_ic(PyObject *module, PyObject *Py_UNUSED(ignored))
2477{
2478 return _curses_has_ic_impl(module);
2479}
2480
2481PyDoc_STRVAR(_curses_has_il__doc__,
2482"has_il($module, /)\n"
2483"--\n"
2484"\n"
2485"Return True if the terminal has insert- and delete-line capabilities.");
2486
2487#define _CURSES_HAS_IL_METHODDEF \
2488 {"has_il", (PyCFunction)_curses_has_il, METH_NOARGS, _curses_has_il__doc__},
2489
2490static PyObject *
2491_curses_has_il_impl(PyObject *module);
2492
2493static PyObject *
2494_curses_has_il(PyObject *module, PyObject *Py_UNUSED(ignored))
2495{
2496 return _curses_has_il_impl(module);
2497}
2498
2499#if defined(HAVE_CURSES_HAS_KEY)
2500
2501PyDoc_STRVAR(_curses_has_key__doc__,
2502"has_key($module, key, /)\n"
2503"--\n"
2504"\n"
2505"Return True if the current terminal type recognizes a key with that value.\n"
2506"\n"
2507" key\n"
2508" Key number.");
2509
2510#define _CURSES_HAS_KEY_METHODDEF \
2511 {"has_key", (PyCFunction)_curses_has_key, METH_O, _curses_has_key__doc__},
2512
2513static PyObject *
2514_curses_has_key_impl(PyObject *module, int key);
2515
2516static PyObject *
2517_curses_has_key(PyObject *module, PyObject *arg)
2518{
2519 PyObject *return_value = NULL;
2520 int key;
2521
2522 key = _PyLong_AsInt(arg);
2523 if (key == -1 && PyErr_Occurred()) {
2524 goto exit;
2525 }
2526 return_value = _curses_has_key_impl(module, key);
2527
2528exit:
2529 return return_value;
2530}
2531
2532#endif /* defined(HAVE_CURSES_HAS_KEY) */
2533
2534PyDoc_STRVAR(_curses_init_color__doc__,
2535"init_color($module, color_number, r, g, b, /)\n"
2536"--\n"
2537"\n"
2538"Change the definition of a color.\n"
2539"\n"
2540" color_number\n"
2541" The number of the color to be changed (0 - (COLORS-1)).\n"
2542" r\n"
2543" Red component (0 - 1000).\n"
2544" g\n"
2545" Green component (0 - 1000).\n"
2546" b\n"
2547" Blue component (0 - 1000).\n"
2548"\n"
2549"When init_color() is used, all occurrences of that color on the screen\n"
2550"immediately change to the new definition. This function is a no-op on\n"
2551"most terminals; it is active only if can_change_color() returns true.");
2552
2553#define _CURSES_INIT_COLOR_METHODDEF \
2554 {"init_color", (PyCFunction)(void(*)(void))_curses_init_color, METH_FASTCALL, _curses_init_color__doc__},
2555
2556static PyObject *
2557_curses_init_color_impl(PyObject *module, int color_number, short r, short g,
2558 short b);
2559
2560static PyObject *
2561_curses_init_color(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2562{
2563 PyObject *return_value = NULL;
2564 int color_number;
2565 short r;
2566 short g;
2567 short b;
2568
2569 if (!_PyArg_CheckPositional("init_color", nargs, 4, 4)) {
2570 goto exit;
2571 }
2572 if (!color_converter(args[0], &color_number)) {
2573 goto exit;
2574 }
2575 if (!component_converter(args[1], &r)) {
2576 goto exit;
2577 }
2578 if (!component_converter(args[2], &g)) {
2579 goto exit;
2580 }
2581 if (!component_converter(args[3], &b)) {
2582 goto exit;
2583 }
2584 return_value = _curses_init_color_impl(module, color_number, r, g, b);
2585
2586exit:
2587 return return_value;
2588}
2589
2590PyDoc_STRVAR(_curses_init_pair__doc__,
2591"init_pair($module, pair_number, fg, bg, /)\n"
2592"--\n"
2593"\n"
2594"Change the definition of a color-pair.\n"
2595"\n"
2596" pair_number\n"
2597" The number of the color-pair to be changed (1 - (COLOR_PAIRS-1)).\n"
2598" fg\n"
2599" Foreground color number (-1 - (COLORS-1)).\n"
2600" bg\n"
2601" Background color number (-1 - (COLORS-1)).\n"
2602"\n"
2603"If the color-pair was previously initialized, the screen is refreshed and\n"
2604"all occurrences of that color-pair are changed to the new definition.");
2605
2606#define _CURSES_INIT_PAIR_METHODDEF \
2607 {"init_pair", (PyCFunction)(void(*)(void))_curses_init_pair, METH_FASTCALL, _curses_init_pair__doc__},
2608
2609static PyObject *
2610_curses_init_pair_impl(PyObject *module, int pair_number, int fg, int bg);
2611
2612static PyObject *
2613_curses_init_pair(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2614{
2615 PyObject *return_value = NULL;
2616 int pair_number;
2617 int fg;
2618 int bg;
2619
2620 if (!_PyArg_CheckPositional("init_pair", nargs, 3, 3)) {
2621 goto exit;
2622 }
2623 if (!pair_converter(args[0], &pair_number)) {
2624 goto exit;
2625 }
2626 if (!color_allow_default_converter(args[1], &fg)) {
2627 goto exit;
2628 }
2629 if (!color_allow_default_converter(args[2], &bg)) {
2630 goto exit;
2631 }
2632 return_value = _curses_init_pair_impl(module, pair_number, fg, bg);
2633
2634exit:
2635 return return_value;
2636}
2637
2638PyDoc_STRVAR(_curses_initscr__doc__,
2639"initscr($module, /)\n"
2640"--\n"
2641"\n"
2642"Initialize the library.\n"
2643"\n"
2644"Return a WindowObject which represents the whole screen.");
2645
2646#define _CURSES_INITSCR_METHODDEF \
2647 {"initscr", (PyCFunction)_curses_initscr, METH_NOARGS, _curses_initscr__doc__},
2648
2649static PyObject *
2650_curses_initscr_impl(PyObject *module);
2651
2652static PyObject *
2653_curses_initscr(PyObject *module, PyObject *Py_UNUSED(ignored))
2654{
2655 return _curses_initscr_impl(module);
2656}
2657
2658PyDoc_STRVAR(_curses_setupterm__doc__,
2659"setupterm($module, /, term=None, fd=-1)\n"
2660"--\n"
2661"\n"
2662"Initialize the terminal.\n"
2663"\n"
2664" term\n"
2665" Terminal name.\n"
2666" If omitted, the value of the TERM environment variable will be used.\n"
2667" fd\n"
2668" File descriptor to which any initialization sequences will be sent.\n"
2669" If not supplied, the file descriptor for sys.stdout will be used.");
2670
2671#define _CURSES_SETUPTERM_METHODDEF \
2672 {"setupterm", (PyCFunction)(void(*)(void))_curses_setupterm, METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
2673
2674static PyObject *
2675_curses_setupterm_impl(PyObject *module, const char *term, int fd);
2676
2677static PyObject *
2678_curses_setupterm(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2679{
2680 PyObject *return_value = NULL;
2681 static const char * const _keywords[] = {"term", "fd", NULL};
2682 static _PyArg_Parser _parser = {NULL, _keywords, "setupterm", 0};
2683 PyObject *argsbuf[2];
2684 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
2685 const char *term = NULL;
2686 int fd = -1;
2687
2688 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
2689 if (!args) {
2690 goto exit;
2691 }
2692 if (!noptargs) {
2693 goto skip_optional_pos;
2694 }
2695 if (args[0]) {
2696 if (args[0] == Py_None) {
2697 term = NULL;
2698 }
2699 else if (PyUnicode_Check(args[0])) {
2700 Py_ssize_t term_length;
2701 term = PyUnicode_AsUTF8AndSize(args[0], &term_length);
2702 if (term == NULL) {
2703 goto exit;
2704 }
2705 if (strlen(term) != (size_t)term_length) {
2706 PyErr_SetString(PyExc_ValueError, "embedded null character");
2707 goto exit;
2708 }
2709 }
2710 else {
2711 _PyArg_BadArgument("setupterm", "argument 'term'", "str or None", args[0]);
2712 goto exit;
2713 }
2714 if (!--noptargs) {
2715 goto skip_optional_pos;
2716 }
2717 }
2718 fd = _PyLong_AsInt(args[1]);
2719 if (fd == -1 && PyErr_Occurred()) {
2720 goto exit;
2721 }
2722skip_optional_pos:
2723 return_value = _curses_setupterm_impl(module, term, fd);
2724
2725exit:
2726 return return_value;
2727}
2728
2729#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
2730
2731PyDoc_STRVAR(_curses_get_escdelay__doc__,
2732"get_escdelay($module, /)\n"
2733"--\n"
2734"\n"
2735"Gets the curses ESCDELAY setting.\n"
2736"\n"
2737"Gets the number of milliseconds to wait after reading an escape character,\n"
2738"to distinguish between an individual escape character entered on the\n"
2739"keyboard from escape sequences sent by cursor and function keys.");
2740
2741#define _CURSES_GET_ESCDELAY_METHODDEF \
2742 {"get_escdelay", (PyCFunction)_curses_get_escdelay, METH_NOARGS, _curses_get_escdelay__doc__},
2743
2744static PyObject *
2745_curses_get_escdelay_impl(PyObject *module);
2746
2747static PyObject *
2748_curses_get_escdelay(PyObject *module, PyObject *Py_UNUSED(ignored))
2749{
2750 return _curses_get_escdelay_impl(module);
2751}
2752
2753#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
2754
2755#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
2756
2757PyDoc_STRVAR(_curses_set_escdelay__doc__,
2758"set_escdelay($module, ms, /)\n"
2759"--\n"
2760"\n"
2761"Sets the curses ESCDELAY setting.\n"
2762"\n"
2763" ms\n"
2764" length of the delay in milliseconds.\n"
2765"\n"
2766"Sets the number of milliseconds to wait after reading an escape character,\n"
2767"to distinguish between an individual escape character entered on the\n"
2768"keyboard from escape sequences sent by cursor and function keys.");
2769
2770#define _CURSES_SET_ESCDELAY_METHODDEF \
2771 {"set_escdelay", (PyCFunction)_curses_set_escdelay, METH_O, _curses_set_escdelay__doc__},
2772
2773static PyObject *
2774_curses_set_escdelay_impl(PyObject *module, int ms);
2775
2776static PyObject *
2777_curses_set_escdelay(PyObject *module, PyObject *arg)
2778{
2779 PyObject *return_value = NULL;
2780 int ms;
2781
2782 ms = _PyLong_AsInt(arg);
2783 if (ms == -1 && PyErr_Occurred()) {
2784 goto exit;
2785 }
2786 return_value = _curses_set_escdelay_impl(module, ms);
2787
2788exit:
2789 return return_value;
2790}
2791
2792#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
2793
2794#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
2795
2796PyDoc_STRVAR(_curses_get_tabsize__doc__,
2797"get_tabsize($module, /)\n"
2798"--\n"
2799"\n"
2800"Gets the curses TABSIZE setting.\n"
2801"\n"
2802"Gets the number of columns used by the curses library when converting a tab\n"
2803"character to spaces as it adds the tab to a window.");
2804
2805#define _CURSES_GET_TABSIZE_METHODDEF \
2806 {"get_tabsize", (PyCFunction)_curses_get_tabsize, METH_NOARGS, _curses_get_tabsize__doc__},
2807
2808static PyObject *
2809_curses_get_tabsize_impl(PyObject *module);
2810
2811static PyObject *
2812_curses_get_tabsize(PyObject *module, PyObject *Py_UNUSED(ignored))
2813{
2814 return _curses_get_tabsize_impl(module);
2815}
2816
2817#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
2818
2819#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
2820
2821PyDoc_STRVAR(_curses_set_tabsize__doc__,
2822"set_tabsize($module, size, /)\n"
2823"--\n"
2824"\n"
2825"Sets the curses TABSIZE setting.\n"
2826"\n"
2827" size\n"
2828" rendered cell width of a tab character.\n"
2829"\n"
2830"Sets the number of columns used by the curses library when converting a tab\n"
2831"character to spaces as it adds the tab to a window.");
2832
2833#define _CURSES_SET_TABSIZE_METHODDEF \
2834 {"set_tabsize", (PyCFunction)_curses_set_tabsize, METH_O, _curses_set_tabsize__doc__},
2835
2836static PyObject *
2837_curses_set_tabsize_impl(PyObject *module, int size);
2838
2839static PyObject *
2840_curses_set_tabsize(PyObject *module, PyObject *arg)
2841{
2842 PyObject *return_value = NULL;
2843 int size;
2844
2845 size = _PyLong_AsInt(arg);
2846 if (size == -1 && PyErr_Occurred()) {
2847 goto exit;
2848 }
2849 return_value = _curses_set_tabsize_impl(module, size);
2850
2851exit:
2852 return return_value;
2853}
2854
2855#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
2856
2857PyDoc_STRVAR(_curses_intrflush__doc__,
2858"intrflush($module, flag, /)\n"
2859"--\n"
2860"\n");
2861
2862#define _CURSES_INTRFLUSH_METHODDEF \
2863 {"intrflush", (PyCFunction)_curses_intrflush, METH_O, _curses_intrflush__doc__},
2864
2865static PyObject *
2866_curses_intrflush_impl(PyObject *module, int flag);
2867
2868static PyObject *
2869_curses_intrflush(PyObject *module, PyObject *arg)
2870{
2871 PyObject *return_value = NULL;
2872 int flag;
2873
2874 flag = _PyLong_AsInt(arg);
2875 if (flag == -1 && PyErr_Occurred()) {
2876 goto exit;
2877 }
2878 return_value = _curses_intrflush_impl(module, flag);
2879
2880exit:
2881 return return_value;
2882}
2883
2884PyDoc_STRVAR(_curses_isendwin__doc__,
2885"isendwin($module, /)\n"
2886"--\n"
2887"\n"
2888"Return True if endwin() has been called.");
2889
2890#define _CURSES_ISENDWIN_METHODDEF \
2891 {"isendwin", (PyCFunction)_curses_isendwin, METH_NOARGS, _curses_isendwin__doc__},
2892
2893static PyObject *
2894_curses_isendwin_impl(PyObject *module);
2895
2896static PyObject *
2897_curses_isendwin(PyObject *module, PyObject *Py_UNUSED(ignored))
2898{
2899 return _curses_isendwin_impl(module);
2900}
2901
2902#if defined(HAVE_CURSES_IS_TERM_RESIZED)
2903
2904PyDoc_STRVAR(_curses_is_term_resized__doc__,
2905"is_term_resized($module, nlines, ncols, /)\n"
2906"--\n"
2907"\n"
2908"Return True if resize_term() would modify the window structure, False otherwise.\n"
2909"\n"
2910" nlines\n"
2911" Height.\n"
2912" ncols\n"
2913" Width.");
2914
2915#define _CURSES_IS_TERM_RESIZED_METHODDEF \
2916 {"is_term_resized", (PyCFunction)(void(*)(void))_curses_is_term_resized, METH_FASTCALL, _curses_is_term_resized__doc__},
2917
2918static PyObject *
2919_curses_is_term_resized_impl(PyObject *module, int nlines, int ncols);
2920
2921static PyObject *
2922_curses_is_term_resized(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2923{
2924 PyObject *return_value = NULL;
2925 int nlines;
2926 int ncols;
2927
2928 if (!_PyArg_CheckPositional("is_term_resized", nargs, 2, 2)) {
2929 goto exit;
2930 }
2931 nlines = _PyLong_AsInt(args[0]);
2932 if (nlines == -1 && PyErr_Occurred()) {
2933 goto exit;
2934 }
2935 ncols = _PyLong_AsInt(args[1]);
2936 if (ncols == -1 && PyErr_Occurred()) {
2937 goto exit;
2938 }
2939 return_value = _curses_is_term_resized_impl(module, nlines, ncols);
2940
2941exit:
2942 return return_value;
2943}
2944
2945#endif /* defined(HAVE_CURSES_IS_TERM_RESIZED) */
2946
2947PyDoc_STRVAR(_curses_keyname__doc__,
2948"keyname($module, key, /)\n"
2949"--\n"
2950"\n"
2951"Return the name of specified key.\n"
2952"\n"
2953" key\n"
2954" Key number.");
2955
2956#define _CURSES_KEYNAME_METHODDEF \
2957 {"keyname", (PyCFunction)_curses_keyname, METH_O, _curses_keyname__doc__},
2958
2959static PyObject *
2960_curses_keyname_impl(PyObject *module, int key);
2961
2962static PyObject *
2963_curses_keyname(PyObject *module, PyObject *arg)
2964{
2965 PyObject *return_value = NULL;
2966 int key;
2967
2968 key = _PyLong_AsInt(arg);
2969 if (key == -1 && PyErr_Occurred()) {
2970 goto exit;
2971 }
2972 return_value = _curses_keyname_impl(module, key);
2973
2974exit:
2975 return return_value;
2976}
2977
2978PyDoc_STRVAR(_curses_killchar__doc__,
2979"killchar($module, /)\n"
2980"--\n"
2981"\n"
2982"Return the user\'s current line kill character.");
2983
2984#define _CURSES_KILLCHAR_METHODDEF \
2985 {"killchar", (PyCFunction)_curses_killchar, METH_NOARGS, _curses_killchar__doc__},
2986
2987static PyObject *
2988_curses_killchar_impl(PyObject *module);
2989
2990static PyObject *
2991_curses_killchar(PyObject *module, PyObject *Py_UNUSED(ignored))
2992{
2993 return _curses_killchar_impl(module);
2994}
2995
2996PyDoc_STRVAR(_curses_longname__doc__,
2997"longname($module, /)\n"
2998"--\n"
2999"\n"
3000"Return the terminfo long name field describing the current terminal.\n"
3001"\n"
3002"The maximum length of a verbose description is 128 characters. It is defined\n"
3003"only after the call to initscr().");
3004
3005#define _CURSES_LONGNAME_METHODDEF \
3006 {"longname", (PyCFunction)_curses_longname, METH_NOARGS, _curses_longname__doc__},
3007
3008static PyObject *
3009_curses_longname_impl(PyObject *module);
3010
3011static PyObject *
3012_curses_longname(PyObject *module, PyObject *Py_UNUSED(ignored))
3013{
3014 return _curses_longname_impl(module);
3015}
3016
3017PyDoc_STRVAR(_curses_meta__doc__,
3018"meta($module, yes, /)\n"
3019"--\n"
3020"\n"
3021"Enable/disable meta keys.\n"
3022"\n"
3023"If yes is True, allow 8-bit characters to be input. If yes is False,\n"
3024"allow only 7-bit characters.");
3025
3026#define _CURSES_META_METHODDEF \
3027 {"meta", (PyCFunction)_curses_meta, METH_O, _curses_meta__doc__},
3028
3029static PyObject *
3030_curses_meta_impl(PyObject *module, int yes);
3031
3032static PyObject *
3033_curses_meta(PyObject *module, PyObject *arg)
3034{
3035 PyObject *return_value = NULL;
3036 int yes;
3037
3038 yes = _PyLong_AsInt(arg);
3039 if (yes == -1 && PyErr_Occurred()) {
3040 goto exit;
3041 }
3042 return_value = _curses_meta_impl(module, yes);
3043
3044exit:
3045 return return_value;
3046}
3047
3048#if defined(NCURSES_MOUSE_VERSION)
3049
3050PyDoc_STRVAR(_curses_mouseinterval__doc__,
3051"mouseinterval($module, interval, /)\n"
3052"--\n"
3053"\n"
3054"Set and retrieve the maximum time between press and release in a click.\n"
3055"\n"
3056" interval\n"
3057" Time in milliseconds.\n"
3058"\n"
3059"Set the maximum time that can elapse between press and release events in\n"
3060"order for them to be recognized as a click, and return the previous interval\n"
3061"value.");
3062
3063#define _CURSES_MOUSEINTERVAL_METHODDEF \
3064 {"mouseinterval", (PyCFunction)_curses_mouseinterval, METH_O, _curses_mouseinterval__doc__},
3065
3066static PyObject *
3067_curses_mouseinterval_impl(PyObject *module, int interval);
3068
3069static PyObject *
3070_curses_mouseinterval(PyObject *module, PyObject *arg)
3071{
3072 PyObject *return_value = NULL;
3073 int interval;
3074
3075 interval = _PyLong_AsInt(arg);
3076 if (interval == -1 && PyErr_Occurred()) {
3077 goto exit;
3078 }
3079 return_value = _curses_mouseinterval_impl(module, interval);
3080
3081exit:
3082 return return_value;
3083}
3084
3085#endif /* defined(NCURSES_MOUSE_VERSION) */
3086
3087#if defined(NCURSES_MOUSE_VERSION)
3088
3089PyDoc_STRVAR(_curses_mousemask__doc__,
3090"mousemask($module, newmask, /)\n"
3091"--\n"
3092"\n"
3093"Set the mouse events to be reported, and return a tuple (availmask, oldmask).\n"
3094"\n"
3095"Return a tuple (availmask, oldmask). availmask indicates which of the\n"
3096"specified mouse events can be reported; on complete failure it returns 0.\n"
3097"oldmask is the previous value of the given window\'s mouse event mask.\n"
3098"If this function is never called, no mouse events are ever reported.");
3099
3100#define _CURSES_MOUSEMASK_METHODDEF \
3101 {"mousemask", (PyCFunction)_curses_mousemask, METH_O, _curses_mousemask__doc__},
3102
3103static PyObject *
3104_curses_mousemask_impl(PyObject *module, unsigned long newmask);
3105
3106static PyObject *
3107_curses_mousemask(PyObject *module, PyObject *arg)
3108{
3109 PyObject *return_value = NULL;
3110 unsigned long newmask;
3111
3112 if (!PyLong_Check(arg)) {
3113 _PyArg_BadArgument("mousemask", "argument", "int", arg);
3114 goto exit;
3115 }
3116 newmask = PyLong_AsUnsignedLongMask(arg);
3117 return_value = _curses_mousemask_impl(module, newmask);
3118
3119exit:
3120 return return_value;
3121}
3122
3123#endif /* defined(NCURSES_MOUSE_VERSION) */
3124
3125PyDoc_STRVAR(_curses_napms__doc__,
3126"napms($module, ms, /)\n"
3127"--\n"
3128"\n"
3129"Sleep for specified time.\n"
3130"\n"
3131" ms\n"
3132" Duration in milliseconds.");
3133
3134#define _CURSES_NAPMS_METHODDEF \
3135 {"napms", (PyCFunction)_curses_napms, METH_O, _curses_napms__doc__},
3136
3137static PyObject *
3138_curses_napms_impl(PyObject *module, int ms);
3139
3140static PyObject *
3141_curses_napms(PyObject *module, PyObject *arg)
3142{
3143 PyObject *return_value = NULL;
3144 int ms;
3145
3146 ms = _PyLong_AsInt(arg);
3147 if (ms == -1 && PyErr_Occurred()) {
3148 goto exit;
3149 }
3150 return_value = _curses_napms_impl(module, ms);
3151
3152exit:
3153 return return_value;
3154}
3155
3156PyDoc_STRVAR(_curses_newpad__doc__,
3157"newpad($module, nlines, ncols, /)\n"
3158"--\n"
3159"\n"
3160"Create and return a pointer to a new pad data structure.\n"
3161"\n"
3162" nlines\n"
3163" Height.\n"
3164" ncols\n"
3165" Width.");
3166
3167#define _CURSES_NEWPAD_METHODDEF \
3168 {"newpad", (PyCFunction)(void(*)(void))_curses_newpad, METH_FASTCALL, _curses_newpad__doc__},
3169
3170static PyObject *
3171_curses_newpad_impl(PyObject *module, int nlines, int ncols);
3172
3173static PyObject *
3174_curses_newpad(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3175{
3176 PyObject *return_value = NULL;
3177 int nlines;
3178 int ncols;
3179
3180 if (!_PyArg_CheckPositional("newpad", nargs, 2, 2)) {
3181 goto exit;
3182 }
3183 nlines = _PyLong_AsInt(args[0]);
3184 if (nlines == -1 && PyErr_Occurred()) {
3185 goto exit;
3186 }
3187 ncols = _PyLong_AsInt(args[1]);
3188 if (ncols == -1 && PyErr_Occurred()) {
3189 goto exit;
3190 }
3191 return_value = _curses_newpad_impl(module, nlines, ncols);
3192
3193exit:
3194 return return_value;
3195}
3196
3197PyDoc_STRVAR(_curses_newwin__doc__,
3198"newwin(nlines, ncols, [begin_y=0, begin_x=0])\n"
3199"Return a new window.\n"
3200"\n"
3201" nlines\n"
3202" Height.\n"
3203" ncols\n"
3204" Width.\n"
3205" begin_y\n"
3206" Top side y-coordinate.\n"
3207" begin_x\n"
3208" Left side x-coordinate.\n"
3209"\n"
3210"By default, the window will extend from the specified position to the lower\n"
3211"right corner of the screen.");
3212
3213#define _CURSES_NEWWIN_METHODDEF \
3214 {"newwin", (PyCFunction)_curses_newwin, METH_VARARGS, _curses_newwin__doc__},
3215
3216static PyObject *
3217_curses_newwin_impl(PyObject *module, int nlines, int ncols,
3218 int group_right_1, int begin_y, int begin_x);
3219
3220static PyObject *
3221_curses_newwin(PyObject *module, PyObject *args)
3222{
3223 PyObject *return_value = NULL;
3224 int nlines;
3225 int ncols;
3226 int group_right_1 = 0;
3227 int begin_y = 0;
3228 int begin_x = 0;
3229
3230 switch (PyTuple_GET_SIZE(args)) {
3231 case 2:
3232 if (!PyArg_ParseTuple(args, "ii:newwin", &nlines, &ncols)) {
3233 goto exit;
3234 }
3235 break;
3236 case 4:
3237 if (!PyArg_ParseTuple(args, "iiii:newwin", &nlines, &ncols, &begin_y, &begin_x)) {
3238 goto exit;
3239 }
3240 group_right_1 = 1;
3241 break;
3242 default:
3243 PyErr_SetString(PyExc_TypeError, "_curses.newwin requires 2 to 4 arguments");
3244 goto exit;
3245 }
3246 return_value = _curses_newwin_impl(module, nlines, ncols, group_right_1, begin_y, begin_x);
3247
3248exit:
3249 return return_value;
3250}
3251
3252PyDoc_STRVAR(_curses_nl__doc__,
3253"nl($module, flag=True, /)\n"
3254"--\n"
3255"\n"
3256"Enter newline mode.\n"
3257"\n"
3258" flag\n"
3259" If false, the effect is the same as calling nonl().\n"
3260"\n"
3261"This mode translates the return key into newline on input, and translates\n"
3262"newline into return and line-feed on output. Newline mode is initially on.");
3263
3264#define _CURSES_NL_METHODDEF \
3265 {"nl", (PyCFunction)(void(*)(void))_curses_nl, METH_FASTCALL, _curses_nl__doc__},
3266
3267static PyObject *
3268_curses_nl_impl(PyObject *module, int flag);
3269
3270static PyObject *
3271_curses_nl(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3272{
3273 PyObject *return_value = NULL;
3274 int flag = 1;
3275
3276 if (!_PyArg_CheckPositional("nl", nargs, 0, 1)) {
3277 goto exit;
3278 }
3279 if (nargs < 1) {
3280 goto skip_optional;
3281 }
3282 flag = _PyLong_AsInt(args[0]);
3283 if (flag == -1 && PyErr_Occurred()) {
3284 goto exit;
3285 }
3286skip_optional:
3287 return_value = _curses_nl_impl(module, flag);
3288
3289exit:
3290 return return_value;
3291}
3292
3293PyDoc_STRVAR(_curses_nocbreak__doc__,
3294"nocbreak($module, /)\n"
3295"--\n"
3296"\n"
3297"Leave cbreak mode.\n"
3298"\n"
3299"Return to normal \"cooked\" mode with line buffering.");
3300
3301#define _CURSES_NOCBREAK_METHODDEF \
3302 {"nocbreak", (PyCFunction)_curses_nocbreak, METH_NOARGS, _curses_nocbreak__doc__},
3303
3304static PyObject *
3305_curses_nocbreak_impl(PyObject *module);
3306
3307static PyObject *
3308_curses_nocbreak(PyObject *module, PyObject *Py_UNUSED(ignored))
3309{
3310 return _curses_nocbreak_impl(module);
3311}
3312
3313PyDoc_STRVAR(_curses_noecho__doc__,
3314"noecho($module, /)\n"
3315"--\n"
3316"\n"
3317"Leave echo mode.\n"
3318"\n"
3319"Echoing of input characters is turned off.");
3320
3321#define _CURSES_NOECHO_METHODDEF \
3322 {"noecho", (PyCFunction)_curses_noecho, METH_NOARGS, _curses_noecho__doc__},
3323
3324static PyObject *
3325_curses_noecho_impl(PyObject *module);
3326
3327static PyObject *
3328_curses_noecho(PyObject *module, PyObject *Py_UNUSED(ignored))
3329{
3330 return _curses_noecho_impl(module);
3331}
3332
3333PyDoc_STRVAR(_curses_nonl__doc__,
3334"nonl($module, /)\n"
3335"--\n"
3336"\n"
3337"Leave newline mode.\n"
3338"\n"
3339"Disable translation of return into newline on input, and disable low-level\n"
3340"translation of newline into newline/return on output.");
3341
3342#define _CURSES_NONL_METHODDEF \
3343 {"nonl", (PyCFunction)_curses_nonl, METH_NOARGS, _curses_nonl__doc__},
3344
3345static PyObject *
3346_curses_nonl_impl(PyObject *module);
3347
3348static PyObject *
3349_curses_nonl(PyObject *module, PyObject *Py_UNUSED(ignored))
3350{
3351 return _curses_nonl_impl(module);
3352}
3353
3354PyDoc_STRVAR(_curses_noqiflush__doc__,
3355"noqiflush($module, /)\n"
3356"--\n"
3357"\n"
3358"Disable queue flushing.\n"
3359"\n"
3360"When queue flushing is disabled, normal flush of input and output queues\n"
3361"associated with the INTR, QUIT and SUSP characters will not be done.");
3362
3363#define _CURSES_NOQIFLUSH_METHODDEF \
3364 {"noqiflush", (PyCFunction)_curses_noqiflush, METH_NOARGS, _curses_noqiflush__doc__},
3365
3366static PyObject *
3367_curses_noqiflush_impl(PyObject *module);
3368
3369static PyObject *
3370_curses_noqiflush(PyObject *module, PyObject *Py_UNUSED(ignored))
3371{
3372 return _curses_noqiflush_impl(module);
3373}
3374
3375PyDoc_STRVAR(_curses_noraw__doc__,
3376"noraw($module, /)\n"
3377"--\n"
3378"\n"
3379"Leave raw mode.\n"
3380"\n"
3381"Return to normal \"cooked\" mode with line buffering.");
3382
3383#define _CURSES_NORAW_METHODDEF \
3384 {"noraw", (PyCFunction)_curses_noraw, METH_NOARGS, _curses_noraw__doc__},
3385
3386static PyObject *
3387_curses_noraw_impl(PyObject *module);
3388
3389static PyObject *
3390_curses_noraw(PyObject *module, PyObject *Py_UNUSED(ignored))
3391{
3392 return _curses_noraw_impl(module);
3393}
3394
3395PyDoc_STRVAR(_curses_pair_content__doc__,
3396"pair_content($module, pair_number, /)\n"
3397"--\n"
3398"\n"
3399"Return a tuple (fg, bg) containing the colors for the requested color pair.\n"
3400"\n"
3401" pair_number\n"
3402" The number of the color pair (0 - (COLOR_PAIRS-1)).");
3403
3404#define _CURSES_PAIR_CONTENT_METHODDEF \
3405 {"pair_content", (PyCFunction)_curses_pair_content, METH_O, _curses_pair_content__doc__},
3406
3407static PyObject *
3408_curses_pair_content_impl(PyObject *module, int pair_number);
3409
3410static PyObject *
3411_curses_pair_content(PyObject *module, PyObject *arg)
3412{
3413 PyObject *return_value = NULL;
3414 int pair_number;
3415
3416 if (!pair_converter(arg, &pair_number)) {
3417 goto exit;
3418 }
3419 return_value = _curses_pair_content_impl(module, pair_number);
3420
3421exit:
3422 return return_value;
3423}
3424
3425PyDoc_STRVAR(_curses_pair_number__doc__,
3426"pair_number($module, attr, /)\n"
3427"--\n"
3428"\n"
3429"Return the number of the color-pair set by the specified attribute value.\n"
3430"\n"
3431"color_pair() is the counterpart to this function.");
3432
3433#define _CURSES_PAIR_NUMBER_METHODDEF \
3434 {"pair_number", (PyCFunction)_curses_pair_number, METH_O, _curses_pair_number__doc__},
3435
3436static PyObject *
3437_curses_pair_number_impl(PyObject *module, int attr);
3438
3439static PyObject *
3440_curses_pair_number(PyObject *module, PyObject *arg)
3441{
3442 PyObject *return_value = NULL;
3443 int attr;
3444
3445 attr = _PyLong_AsInt(arg);
3446 if (attr == -1 && PyErr_Occurred()) {
3447 goto exit;
3448 }
3449 return_value = _curses_pair_number_impl(module, attr);
3450
3451exit:
3452 return return_value;
3453}
3454
3455PyDoc_STRVAR(_curses_putp__doc__,
3456"putp($module, string, /)\n"
3457"--\n"
3458"\n"
3459"Emit the value of a specified terminfo capability for the current terminal.\n"
3460"\n"
3461"Note that the output of putp() always goes to standard output.");
3462
3463#define _CURSES_PUTP_METHODDEF \
3464 {"putp", (PyCFunction)_curses_putp, METH_O, _curses_putp__doc__},
3465
3466static PyObject *
3467_curses_putp_impl(PyObject *module, const char *string);
3468
3469static PyObject *
3470_curses_putp(PyObject *module, PyObject *arg)
3471{
3472 PyObject *return_value = NULL;
3473 const char *string;
3474
3475 if (!PyArg_Parse(arg, "y:putp", &string)) {
3476 goto exit;
3477 }
3478 return_value = _curses_putp_impl(module, string);
3479
3480exit:
3481 return return_value;
3482}
3483
3484PyDoc_STRVAR(_curses_qiflush__doc__,
3485"qiflush($module, flag=True, /)\n"
3486"--\n"
3487"\n"
3488"Enable queue flushing.\n"
3489"\n"
3490" flag\n"
3491" If false, the effect is the same as calling noqiflush().\n"
3492"\n"
3493"If queue flushing is enabled, all output in the display driver queue\n"
3494"will be flushed when the INTR, QUIT and SUSP characters are read.");
3495
3496#define _CURSES_QIFLUSH_METHODDEF \
3497 {"qiflush", (PyCFunction)(void(*)(void))_curses_qiflush, METH_FASTCALL, _curses_qiflush__doc__},
3498
3499static PyObject *
3500_curses_qiflush_impl(PyObject *module, int flag);
3501
3502static PyObject *
3503_curses_qiflush(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3504{
3505 PyObject *return_value = NULL;
3506 int flag = 1;
3507
3508 if (!_PyArg_CheckPositional("qiflush", nargs, 0, 1)) {
3509 goto exit;
3510 }
3511 if (nargs < 1) {
3512 goto skip_optional;
3513 }
3514 flag = _PyLong_AsInt(args[0]);
3515 if (flag == -1 && PyErr_Occurred()) {
3516 goto exit;
3517 }
3518skip_optional:
3519 return_value = _curses_qiflush_impl(module, flag);
3520
3521exit:
3522 return return_value;
3523}
3524
3525#if (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM))
3526
3527PyDoc_STRVAR(_curses_update_lines_cols__doc__,
3528"update_lines_cols($module, /)\n"
3529"--\n"
3530"\n");
3531
3532#define _CURSES_UPDATE_LINES_COLS_METHODDEF \
3533 {"update_lines_cols", (PyCFunction)_curses_update_lines_cols, METH_NOARGS, _curses_update_lines_cols__doc__},
3534
3535static PyObject *
3536_curses_update_lines_cols_impl(PyObject *module);
3537
3538static PyObject *
3539_curses_update_lines_cols(PyObject *module, PyObject *Py_UNUSED(ignored))
3540{
3541 return _curses_update_lines_cols_impl(module);
3542}
3543
3544#endif /* (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM)) */
3545
3546PyDoc_STRVAR(_curses_raw__doc__,
3547"raw($module, flag=True, /)\n"
3548"--\n"
3549"\n"
3550"Enter raw mode.\n"
3551"\n"
3552" flag\n"
3553" If false, the effect is the same as calling noraw().\n"
3554"\n"
3555"In raw mode, normal line buffering and processing of interrupt, quit,\n"
3556"suspend, and flow control keys are turned off; characters are presented to\n"
3557"curses input functions one by one.");
3558
3559#define _CURSES_RAW_METHODDEF \
3560 {"raw", (PyCFunction)(void(*)(void))_curses_raw, METH_FASTCALL, _curses_raw__doc__},
3561
3562static PyObject *
3563_curses_raw_impl(PyObject *module, int flag);
3564
3565static PyObject *
3566_curses_raw(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3567{
3568 PyObject *return_value = NULL;
3569 int flag = 1;
3570
3571 if (!_PyArg_CheckPositional("raw", nargs, 0, 1)) {
3572 goto exit;
3573 }
3574 if (nargs < 1) {
3575 goto skip_optional;
3576 }
3577 flag = _PyLong_AsInt(args[0]);
3578 if (flag == -1 && PyErr_Occurred()) {
3579 goto exit;
3580 }
3581skip_optional:
3582 return_value = _curses_raw_impl(module, flag);
3583
3584exit:
3585 return return_value;
3586}
3587
3588PyDoc_STRVAR(_curses_reset_prog_mode__doc__,
3589"reset_prog_mode($module, /)\n"
3590"--\n"
3591"\n"
3592"Restore the terminal to \"program\" mode, as previously saved by def_prog_mode().");
3593
3594#define _CURSES_RESET_PROG_MODE_METHODDEF \
3595 {"reset_prog_mode", (PyCFunction)_curses_reset_prog_mode, METH_NOARGS, _curses_reset_prog_mode__doc__},
3596
3597static PyObject *
3598_curses_reset_prog_mode_impl(PyObject *module);
3599
3600static PyObject *
3601_curses_reset_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
3602{
3603 return _curses_reset_prog_mode_impl(module);
3604}
3605
3606PyDoc_STRVAR(_curses_reset_shell_mode__doc__,
3607"reset_shell_mode($module, /)\n"
3608"--\n"
3609"\n"
3610"Restore the terminal to \"shell\" mode, as previously saved by def_shell_mode().");
3611
3612#define _CURSES_RESET_SHELL_MODE_METHODDEF \
3613 {"reset_shell_mode", (PyCFunction)_curses_reset_shell_mode, METH_NOARGS, _curses_reset_shell_mode__doc__},
3614
3615static PyObject *
3616_curses_reset_shell_mode_impl(PyObject *module);
3617
3618static PyObject *
3619_curses_reset_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
3620{
3621 return _curses_reset_shell_mode_impl(module);
3622}
3623
3624PyDoc_STRVAR(_curses_resetty__doc__,
3625"resetty($module, /)\n"
3626"--\n"
3627"\n"
3628"Restore terminal mode.");
3629
3630#define _CURSES_RESETTY_METHODDEF \
3631 {"resetty", (PyCFunction)_curses_resetty, METH_NOARGS, _curses_resetty__doc__},
3632
3633static PyObject *
3634_curses_resetty_impl(PyObject *module);
3635
3636static PyObject *
3637_curses_resetty(PyObject *module, PyObject *Py_UNUSED(ignored))
3638{
3639 return _curses_resetty_impl(module);
3640}
3641
3642#if defined(HAVE_CURSES_RESIZETERM)
3643
3644PyDoc_STRVAR(_curses_resizeterm__doc__,
3645"resizeterm($module, nlines, ncols, /)\n"
3646"--\n"
3647"\n"
3648"Resize the standard and current windows to the specified dimensions.\n"
3649"\n"
3650" nlines\n"
3651" Height.\n"
3652" ncols\n"
3653" Width.\n"
3654"\n"
3655"Adjusts other bookkeeping data used by the curses library that record the\n"
3656"window dimensions (in particular the SIGWINCH handler).");
3657
3658#define _CURSES_RESIZETERM_METHODDEF \
3659 {"resizeterm", (PyCFunction)(void(*)(void))_curses_resizeterm, METH_FASTCALL, _curses_resizeterm__doc__},
3660
3661static PyObject *
3662_curses_resizeterm_impl(PyObject *module, int nlines, int ncols);
3663
3664static PyObject *
3665_curses_resizeterm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3666{
3667 PyObject *return_value = NULL;
3668 int nlines;
3669 int ncols;
3670
3671 if (!_PyArg_CheckPositional("resizeterm", nargs, 2, 2)) {
3672 goto exit;
3673 }
3674 nlines = _PyLong_AsInt(args[0]);
3675 if (nlines == -1 && PyErr_Occurred()) {
3676 goto exit;
3677 }
3678 ncols = _PyLong_AsInt(args[1]);
3679 if (ncols == -1 && PyErr_Occurred()) {
3680 goto exit;
3681 }
3682 return_value = _curses_resizeterm_impl(module, nlines, ncols);
3683
3684exit:
3685 return return_value;
3686}
3687
3688#endif /* defined(HAVE_CURSES_RESIZETERM) */
3689
3690#if defined(HAVE_CURSES_RESIZE_TERM)
3691
3692PyDoc_STRVAR(_curses_resize_term__doc__,
3693"resize_term($module, nlines, ncols, /)\n"
3694"--\n"
3695"\n"
3696"Backend function used by resizeterm(), performing most of the work.\n"
3697"\n"
3698" nlines\n"
3699" Height.\n"
3700" ncols\n"
3701" Width.\n"
3702"\n"
3703"When resizing the windows, resize_term() blank-fills the areas that are\n"
3704"extended. The calling application should fill in these areas with appropriate\n"
3705"data. The resize_term() function attempts to resize all windows. However,\n"
3706"due to the calling convention of pads, it is not possible to resize these\n"
3707"without additional interaction with the application.");
3708
3709#define _CURSES_RESIZE_TERM_METHODDEF \
3710 {"resize_term", (PyCFunction)(void(*)(void))_curses_resize_term, METH_FASTCALL, _curses_resize_term__doc__},
3711
3712static PyObject *
3713_curses_resize_term_impl(PyObject *module, int nlines, int ncols);
3714
3715static PyObject *
3716_curses_resize_term(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3717{
3718 PyObject *return_value = NULL;
3719 int nlines;
3720 int ncols;
3721
3722 if (!_PyArg_CheckPositional("resize_term", nargs, 2, 2)) {
3723 goto exit;
3724 }
3725 nlines = _PyLong_AsInt(args[0]);
3726 if (nlines == -1 && PyErr_Occurred()) {
3727 goto exit;
3728 }
3729 ncols = _PyLong_AsInt(args[1]);
3730 if (ncols == -1 && PyErr_Occurred()) {
3731 goto exit;
3732 }
3733 return_value = _curses_resize_term_impl(module, nlines, ncols);
3734
3735exit:
3736 return return_value;
3737}
3738
3739#endif /* defined(HAVE_CURSES_RESIZE_TERM) */
3740
3741PyDoc_STRVAR(_curses_savetty__doc__,
3742"savetty($module, /)\n"
3743"--\n"
3744"\n"
3745"Save terminal mode.");
3746
3747#define _CURSES_SAVETTY_METHODDEF \
3748 {"savetty", (PyCFunction)_curses_savetty, METH_NOARGS, _curses_savetty__doc__},
3749
3750static PyObject *
3751_curses_savetty_impl(PyObject *module);
3752
3753static PyObject *
3754_curses_savetty(PyObject *module, PyObject *Py_UNUSED(ignored))
3755{
3756 return _curses_savetty_impl(module);
3757}
3758
3759#if defined(getsyx)
3760
3761PyDoc_STRVAR(_curses_setsyx__doc__,
3762"setsyx($module, y, x, /)\n"
3763"--\n"
3764"\n"
3765"Set the virtual screen cursor.\n"
3766"\n"
3767" y\n"
3768" Y-coordinate.\n"
3769" x\n"
3770" X-coordinate.\n"
3771"\n"
3772"If y and x are both -1, then leaveok is set.");
3773
3774#define _CURSES_SETSYX_METHODDEF \
3775 {"setsyx", (PyCFunction)(void(*)(void))_curses_setsyx, METH_FASTCALL, _curses_setsyx__doc__},
3776
3777static PyObject *
3778_curses_setsyx_impl(PyObject *module, int y, int x);
3779
3780static PyObject *
3781_curses_setsyx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3782{
3783 PyObject *return_value = NULL;
3784 int y;
3785 int x;
3786
3787 if (!_PyArg_CheckPositional("setsyx", nargs, 2, 2)) {
3788 goto exit;
3789 }
3790 y = _PyLong_AsInt(args[0]);
3791 if (y == -1 && PyErr_Occurred()) {
3792 goto exit;
3793 }
3794 x = _PyLong_AsInt(args[1]);
3795 if (x == -1 && PyErr_Occurred()) {
3796 goto exit;
3797 }
3798 return_value = _curses_setsyx_impl(module, y, x);
3799
3800exit:
3801 return return_value;
3802}
3803
3804#endif /* defined(getsyx) */
3805
3806PyDoc_STRVAR(_curses_start_color__doc__,
3807"start_color($module, /)\n"
3808"--\n"
3809"\n"
3810"Initializes eight basic colors and global variables COLORS and COLOR_PAIRS.\n"
3811"\n"
3812"Must be called if the programmer wants to use colors, and before any other\n"
3813"color manipulation routine is called. It is good practice to call this\n"
3814"routine right after initscr().\n"
3815"\n"
3816"It also restores the colors on the terminal to the values they had when the\n"
3817"terminal was just turned on.");
3818
3819#define _CURSES_START_COLOR_METHODDEF \
3820 {"start_color", (PyCFunction)_curses_start_color, METH_NOARGS, _curses_start_color__doc__},
3821
3822static PyObject *
3823_curses_start_color_impl(PyObject *module);
3824
3825static PyObject *
3826_curses_start_color(PyObject *module, PyObject *Py_UNUSED(ignored))
3827{
3828 return _curses_start_color_impl(module);
3829}
3830
3831PyDoc_STRVAR(_curses_termattrs__doc__,
3832"termattrs($module, /)\n"
3833"--\n"
3834"\n"
3835"Return a logical OR of all video attributes supported by the terminal.");
3836
3837#define _CURSES_TERMATTRS_METHODDEF \
3838 {"termattrs", (PyCFunction)_curses_termattrs, METH_NOARGS, _curses_termattrs__doc__},
3839
3840static PyObject *
3841_curses_termattrs_impl(PyObject *module);
3842
3843static PyObject *
3844_curses_termattrs(PyObject *module, PyObject *Py_UNUSED(ignored))
3845{
3846 return _curses_termattrs_impl(module);
3847}
3848
3849PyDoc_STRVAR(_curses_termname__doc__,
3850"termname($module, /)\n"
3851"--\n"
3852"\n"
3853"Return the value of the environment variable TERM, truncated to 14 characters.");
3854
3855#define _CURSES_TERMNAME_METHODDEF \
3856 {"termname", (PyCFunction)_curses_termname, METH_NOARGS, _curses_termname__doc__},
3857
3858static PyObject *
3859_curses_termname_impl(PyObject *module);
3860
3861static PyObject *
3862_curses_termname(PyObject *module, PyObject *Py_UNUSED(ignored))
3863{
3864 return _curses_termname_impl(module);
3865}
3866
3867PyDoc_STRVAR(_curses_tigetflag__doc__,
3868"tigetflag($module, capname, /)\n"
3869"--\n"
3870"\n"
3871"Return the value of the Boolean capability.\n"
3872"\n"
3873" capname\n"
3874" The terminfo capability name.\n"
3875"\n"
3876"The value -1 is returned if capname is not a Boolean capability, or 0 if\n"
3877"it is canceled or absent from the terminal description.");
3878
3879#define _CURSES_TIGETFLAG_METHODDEF \
3880 {"tigetflag", (PyCFunction)_curses_tigetflag, METH_O, _curses_tigetflag__doc__},
3881
3882static PyObject *
3883_curses_tigetflag_impl(PyObject *module, const char *capname);
3884
3885static PyObject *
3886_curses_tigetflag(PyObject *module, PyObject *arg)
3887{
3888 PyObject *return_value = NULL;
3889 const char *capname;
3890
3891 if (!PyUnicode_Check(arg)) {
3892 _PyArg_BadArgument("tigetflag", "argument", "str", arg);
3893 goto exit;
3894 }
3895 Py_ssize_t capname_length;
3896 capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3897 if (capname == NULL) {
3898 goto exit;
3899 }
3900 if (strlen(capname) != (size_t)capname_length) {
3901 PyErr_SetString(PyExc_ValueError, "embedded null character");
3902 goto exit;
3903 }
3904 return_value = _curses_tigetflag_impl(module, capname);
3905
3906exit:
3907 return return_value;
3908}
3909
3910PyDoc_STRVAR(_curses_tigetnum__doc__,
3911"tigetnum($module, capname, /)\n"
3912"--\n"
3913"\n"
3914"Return the value of the numeric capability.\n"
3915"\n"
3916" capname\n"
3917" The terminfo capability name.\n"
3918"\n"
3919"The value -2 is returned if capname is not a numeric capability, or -1 if\n"
3920"it is canceled or absent from the terminal description.");
3921
3922#define _CURSES_TIGETNUM_METHODDEF \
3923 {"tigetnum", (PyCFunction)_curses_tigetnum, METH_O, _curses_tigetnum__doc__},
3924
3925static PyObject *
3926_curses_tigetnum_impl(PyObject *module, const char *capname);
3927
3928static PyObject *
3929_curses_tigetnum(PyObject *module, PyObject *arg)
3930{
3931 PyObject *return_value = NULL;
3932 const char *capname;
3933
3934 if (!PyUnicode_Check(arg)) {
3935 _PyArg_BadArgument("tigetnum", "argument", "str", arg);
3936 goto exit;
3937 }
3938 Py_ssize_t capname_length;
3939 capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3940 if (capname == NULL) {
3941 goto exit;
3942 }
3943 if (strlen(capname) != (size_t)capname_length) {
3944 PyErr_SetString(PyExc_ValueError, "embedded null character");
3945 goto exit;
3946 }
3947 return_value = _curses_tigetnum_impl(module, capname);
3948
3949exit:
3950 return return_value;
3951}
3952
3953PyDoc_STRVAR(_curses_tigetstr__doc__,
3954"tigetstr($module, capname, /)\n"
3955"--\n"
3956"\n"
3957"Return the value of the string capability.\n"
3958"\n"
3959" capname\n"
3960" The terminfo capability name.\n"
3961"\n"
3962"None is returned if capname is not a string capability, or is canceled or\n"
3963"absent from the terminal description.");
3964
3965#define _CURSES_TIGETSTR_METHODDEF \
3966 {"tigetstr", (PyCFunction)_curses_tigetstr, METH_O, _curses_tigetstr__doc__},
3967
3968static PyObject *
3969_curses_tigetstr_impl(PyObject *module, const char *capname);
3970
3971static PyObject *
3972_curses_tigetstr(PyObject *module, PyObject *arg)
3973{
3974 PyObject *return_value = NULL;
3975 const char *capname;
3976
3977 if (!PyUnicode_Check(arg)) {
3978 _PyArg_BadArgument("tigetstr", "argument", "str", arg);
3979 goto exit;
3980 }
3981 Py_ssize_t capname_length;
3982 capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3983 if (capname == NULL) {
3984 goto exit;
3985 }
3986 if (strlen(capname) != (size_t)capname_length) {
3987 PyErr_SetString(PyExc_ValueError, "embedded null character");
3988 goto exit;
3989 }
3990 return_value = _curses_tigetstr_impl(module, capname);
3991
3992exit:
3993 return return_value;
3994}
3995
3996PyDoc_STRVAR(_curses_tparm__doc__,
3997"tparm($module, str, i1=0, i2=0, i3=0, i4=0, i5=0, i6=0, i7=0, i8=0,\n"
3998" i9=0, /)\n"
3999"--\n"
4000"\n"
4001"Instantiate the specified byte string with the supplied parameters.\n"
4002"\n"
4003" str\n"
4004" Parameterized byte string obtained from the terminfo database.");
4005
4006#define _CURSES_TPARM_METHODDEF \
4007 {"tparm", (PyCFunction)(void(*)(void))_curses_tparm, METH_FASTCALL, _curses_tparm__doc__},
4008
4009static PyObject *
4010_curses_tparm_impl(PyObject *module, const char *str, int i1, int i2, int i3,
4011 int i4, int i5, int i6, int i7, int i8, int i9);
4012
4013static PyObject *
4014_curses_tparm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
4015{
4016 PyObject *return_value = NULL;
4017 const char *str;
4018 int i1 = 0;
4019 int i2 = 0;
4020 int i3 = 0;
4021 int i4 = 0;
4022 int i5 = 0;
4023 int i6 = 0;
4024 int i7 = 0;
4025 int i8 = 0;
4026 int i9 = 0;
4027
4028 if (!_PyArg_ParseStack(args, nargs, "y|iiiiiiiii:tparm",
4029 &str, &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9)) {
4030 goto exit;
4031 }
4032 return_value = _curses_tparm_impl(module, str, i1, i2, i3, i4, i5, i6, i7, i8, i9);
4033
4034exit:
4035 return return_value;
4036}
4037
4038#if defined(HAVE_CURSES_TYPEAHEAD)
4039
4040PyDoc_STRVAR(_curses_typeahead__doc__,
4041"typeahead($module, fd, /)\n"
4042"--\n"
4043"\n"
4044"Specify that the file descriptor fd be used for typeahead checking.\n"
4045"\n"
4046" fd\n"
4047" File descriptor.\n"
4048"\n"
4049"If fd is -1, then no typeahead checking is done.");
4050
4051#define _CURSES_TYPEAHEAD_METHODDEF \
4052 {"typeahead", (PyCFunction)_curses_typeahead, METH_O, _curses_typeahead__doc__},
4053
4054static PyObject *
4055_curses_typeahead_impl(PyObject *module, int fd);
4056
4057static PyObject *
4058_curses_typeahead(PyObject *module, PyObject *arg)
4059{
4060 PyObject *return_value = NULL;
4061 int fd;
4062
4063 fd = _PyLong_AsInt(arg);
4064 if (fd == -1 && PyErr_Occurred()) {
4065 goto exit;
4066 }
4067 return_value = _curses_typeahead_impl(module, fd);
4068
4069exit:
4070 return return_value;
4071}
4072
4073#endif /* defined(HAVE_CURSES_TYPEAHEAD) */
4074
4075PyDoc_STRVAR(_curses_unctrl__doc__,
4076"unctrl($module, ch, /)\n"
4077"--\n"
4078"\n"
4079"Return a string which is a printable representation of the character ch.\n"
4080"\n"
4081"Control characters are displayed as a caret followed by the character,\n"
4082"for example as ^C. Printing characters are left as they are.");
4083
4084#define _CURSES_UNCTRL_METHODDEF \
4085 {"unctrl", (PyCFunction)_curses_unctrl, METH_O, _curses_unctrl__doc__},
4086
4087PyDoc_STRVAR(_curses_ungetch__doc__,
4088"ungetch($module, ch, /)\n"
4089"--\n"
4090"\n"
4091"Push ch so the next getch() will return it.");
4092
4093#define _CURSES_UNGETCH_METHODDEF \
4094 {"ungetch", (PyCFunction)_curses_ungetch, METH_O, _curses_ungetch__doc__},
4095
4096#if defined(HAVE_NCURSESW)
4097
4098PyDoc_STRVAR(_curses_unget_wch__doc__,
4099"unget_wch($module, ch, /)\n"
4100"--\n"
4101"\n"
4102"Push ch so the next get_wch() will return it.");
4103
4104#define _CURSES_UNGET_WCH_METHODDEF \
4105 {"unget_wch", (PyCFunction)_curses_unget_wch, METH_O, _curses_unget_wch__doc__},
4106
4107#endif /* defined(HAVE_NCURSESW) */
4108
4109#if defined(HAVE_CURSES_USE_ENV)
4110
4111PyDoc_STRVAR(_curses_use_env__doc__,
4112"use_env($module, flag, /)\n"
4113"--\n"
4114"\n"
4115"Use environment variables LINES and COLUMNS.\n"
4116"\n"
4117"If used, this function should be called before initscr() or newterm() are\n"
4118"called.\n"
4119"\n"
4120"When flag is False, the values of lines and columns specified in the terminfo\n"
4121"database will be used, even if environment variables LINES and COLUMNS (used\n"
4122"by default) are set, or if curses is running in a window (in which case\n"
4123"default behavior would be to use the window size if LINES and COLUMNS are\n"
4124"not set).");
4125
4126#define _CURSES_USE_ENV_METHODDEF \
4127 {"use_env", (PyCFunction)_curses_use_env, METH_O, _curses_use_env__doc__},
4128
4129static PyObject *
4130_curses_use_env_impl(PyObject *module, int flag);
4131
4132static PyObject *
4133_curses_use_env(PyObject *module, PyObject *arg)
4134{
4135 PyObject *return_value = NULL;
4136 int flag;
4137
4138 flag = _PyLong_AsInt(arg);
4139 if (flag == -1 && PyErr_Occurred()) {
4140 goto exit;
4141 }
4142 return_value = _curses_use_env_impl(module, flag);
4143
4144exit:
4145 return return_value;
4146}
4147
4148#endif /* defined(HAVE_CURSES_USE_ENV) */
4149
4150#if !defined(STRICT_SYSV_CURSES)
4151
4152PyDoc_STRVAR(_curses_use_default_colors__doc__,
4153"use_default_colors($module, /)\n"
4154"--\n"
4155"\n"
4156"Allow use of default values for colors on terminals supporting this feature.\n"
4157"\n"
4158"Use this to support transparency in your application. The default color\n"
4159"is assigned to the color number -1.");
4160
4161#define _CURSES_USE_DEFAULT_COLORS_METHODDEF \
4162 {"use_default_colors", (PyCFunction)_curses_use_default_colors, METH_NOARGS, _curses_use_default_colors__doc__},
4163
4164static PyObject *
4165_curses_use_default_colors_impl(PyObject *module);
4166
4167static PyObject *
4168_curses_use_default_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
4169{
4170 return _curses_use_default_colors_impl(module);
4171}
4172
4173#endif /* !defined(STRICT_SYSV_CURSES) */
4174
4175PyDoc_STRVAR(_curses_has_extended_color_support__doc__,
4176"has_extended_color_support($module, /)\n"
4177"--\n"
4178"\n"
4179"Return True if the module supports extended colors; otherwise, return False.\n"
4180"\n"
4181"Extended color support allows more than 256 color-pairs for terminals\n"
4182"that support more than 16 colors (e.g. xterm-256color).");
4183
4184#define _CURSES_HAS_EXTENDED_COLOR_SUPPORT_METHODDEF \
4185 {"has_extended_color_support", (PyCFunction)_curses_has_extended_color_support, METH_NOARGS, _curses_has_extended_color_support__doc__},
4186
4187static PyObject *
4188_curses_has_extended_color_support_impl(PyObject *module);
4189
4190static PyObject *
4191_curses_has_extended_color_support(PyObject *module, PyObject *Py_UNUSED(ignored))
4192{
4193 return _curses_has_extended_color_support_impl(module);
4194}
4195
4196#ifndef _CURSES_WINDOW_ENCLOSE_METHODDEF
4197 #define _CURSES_WINDOW_ENCLOSE_METHODDEF
4198#endif /* !defined(_CURSES_WINDOW_ENCLOSE_METHODDEF) */
4199
4200#ifndef _CURSES_WINDOW_GET_WCH_METHODDEF
4201 #define _CURSES_WINDOW_GET_WCH_METHODDEF
4202#endif /* !defined(_CURSES_WINDOW_GET_WCH_METHODDEF) */
4203
4204#ifndef _CURSES_WINDOW_NOUTREFRESH_METHODDEF
4205 #define _CURSES_WINDOW_NOUTREFRESH_METHODDEF
4206#endif /* !defined(_CURSES_WINDOW_NOUTREFRESH_METHODDEF) */
4207
4208#ifndef _CURSES_FILTER_METHODDEF
4209 #define _CURSES_FILTER_METHODDEF
4210#endif /* !defined(_CURSES_FILTER_METHODDEF) */
4211
4212#ifndef _CURSES_GETSYX_METHODDEF
4213 #define _CURSES_GETSYX_METHODDEF
4214#endif /* !defined(_CURSES_GETSYX_METHODDEF) */
4215
4216#ifndef _CURSES_GETMOUSE_METHODDEF
4217 #define _CURSES_GETMOUSE_METHODDEF
4218#endif /* !defined(_CURSES_GETMOUSE_METHODDEF) */
4219
4220#ifndef _CURSES_UNGETMOUSE_METHODDEF
4221 #define _CURSES_UNGETMOUSE_METHODDEF
4222#endif /* !defined(_CURSES_UNGETMOUSE_METHODDEF) */
4223
4224#ifndef _CURSES_HAS_KEY_METHODDEF
4225 #define _CURSES_HAS_KEY_METHODDEF
4226#endif /* !defined(_CURSES_HAS_KEY_METHODDEF) */
4227
4228#ifndef _CURSES_GET_ESCDELAY_METHODDEF
4229 #define _CURSES_GET_ESCDELAY_METHODDEF
4230#endif /* !defined(_CURSES_GET_ESCDELAY_METHODDEF) */
4231
4232#ifndef _CURSES_SET_ESCDELAY_METHODDEF
4233 #define _CURSES_SET_ESCDELAY_METHODDEF
4234#endif /* !defined(_CURSES_SET_ESCDELAY_METHODDEF) */
4235
4236#ifndef _CURSES_GET_TABSIZE_METHODDEF
4237 #define _CURSES_GET_TABSIZE_METHODDEF
4238#endif /* !defined(_CURSES_GET_TABSIZE_METHODDEF) */
4239
4240#ifndef _CURSES_SET_TABSIZE_METHODDEF
4241 #define _CURSES_SET_TABSIZE_METHODDEF
4242#endif /* !defined(_CURSES_SET_TABSIZE_METHODDEF) */
4243
4244#ifndef _CURSES_IS_TERM_RESIZED_METHODDEF
4245 #define _CURSES_IS_TERM_RESIZED_METHODDEF
4246#endif /* !defined(_CURSES_IS_TERM_RESIZED_METHODDEF) */
4247
4248#ifndef _CURSES_MOUSEINTERVAL_METHODDEF
4249 #define _CURSES_MOUSEINTERVAL_METHODDEF
4250#endif /* !defined(_CURSES_MOUSEINTERVAL_METHODDEF) */
4251
4252#ifndef _CURSES_MOUSEMASK_METHODDEF
4253 #define _CURSES_MOUSEMASK_METHODDEF
4254#endif /* !defined(_CURSES_MOUSEMASK_METHODDEF) */
4255
4256#ifndef _CURSES_UPDATE_LINES_COLS_METHODDEF
4257 #define _CURSES_UPDATE_LINES_COLS_METHODDEF
4258#endif /* !defined(_CURSES_UPDATE_LINES_COLS_METHODDEF) */
4259
4260#ifndef _CURSES_RESIZETERM_METHODDEF
4261 #define _CURSES_RESIZETERM_METHODDEF
4262#endif /* !defined(_CURSES_RESIZETERM_METHODDEF) */
4263
4264#ifndef _CURSES_RESIZE_TERM_METHODDEF
4265 #define _CURSES_RESIZE_TERM_METHODDEF
4266#endif /* !defined(_CURSES_RESIZE_TERM_METHODDEF) */
4267
4268#ifndef _CURSES_SETSYX_METHODDEF
4269 #define _CURSES_SETSYX_METHODDEF
4270#endif /* !defined(_CURSES_SETSYX_METHODDEF) */
4271
4272#ifndef _CURSES_TYPEAHEAD_METHODDEF
4273 #define _CURSES_TYPEAHEAD_METHODDEF
4274#endif /* !defined(_CURSES_TYPEAHEAD_METHODDEF) */
4275
4276#ifndef _CURSES_UNGET_WCH_METHODDEF
4277 #define _CURSES_UNGET_WCH_METHODDEF
4278#endif /* !defined(_CURSES_UNGET_WCH_METHODDEF) */
4279
4280#ifndef _CURSES_USE_ENV_METHODDEF
4281 #define _CURSES_USE_ENV_METHODDEF
4282#endif /* !defined(_CURSES_USE_ENV_METHODDEF) */
4283
4284#ifndef _CURSES_USE_DEFAULT_COLORS_METHODDEF
4285 #define _CURSES_USE_DEFAULT_COLORS_METHODDEF
4286#endif /* !defined(_CURSES_USE_DEFAULT_COLORS_METHODDEF) */
4287/*[clinic end generated code: output=9efc9943a3ac3741 input=a9049054013a1b77]*/
4288