Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_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 : :
26 : : static 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 : :
31 : : static PyObject *
32 : 47 : _curses_window_addch(PyCursesWindowObject *self, PyObject *args)
33 : : {
34 : 47 : PyObject *return_value = NULL;
35 : 47 : int group_left_1 = 0;
36 : 47 : int y = 0;
37 : 47 : int x = 0;
38 : : PyObject *ch;
39 : 47 : int group_right_1 = 0;
40 : 47 : long attr = A_NORMAL;
41 : :
42 [ + + + + : 47 : switch (PyTuple_GET_SIZE(args)) {
- ]
43 : 44 : case 1:
44 [ - + ]: 44 : if (!PyArg_ParseTuple(args, "O:addch", &ch)) {
45 : 0 : goto exit;
46 : : }
47 : 44 : break;
48 : 1 : case 2:
49 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Ol:addch", &ch, &attr)) {
50 : 0 : goto exit;
51 : : }
52 : 1 : group_right_1 = 1;
53 : 1 : break;
54 : 1 : case 3:
55 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiO:addch", &y, &x, &ch)) {
56 : 0 : goto exit;
57 : : }
58 : 1 : group_left_1 = 1;
59 : 1 : break;
60 : 1 : case 4:
61 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOl:addch", &y, &x, &ch, &attr)) {
62 : 0 : goto exit;
63 : : }
64 : 1 : group_right_1 = 1;
65 : 1 : group_left_1 = 1;
66 : 1 : break;
67 : 0 : default:
68 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.addch requires 1 to 4 arguments");
69 : 0 : goto exit;
70 : : }
71 : 47 : return_value = _curses_window_addch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
72 : :
73 : 47 : exit:
74 : 47 : return return_value;
75 : : }
76 : :
77 : : PyDoc_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 : :
98 : : static 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 : :
103 : : static PyObject *
104 : 59 : _curses_window_addstr(PyCursesWindowObject *self, PyObject *args)
105 : : {
106 : 59 : PyObject *return_value = NULL;
107 : 59 : int group_left_1 = 0;
108 : 59 : int y = 0;
109 : 59 : int x = 0;
110 : : PyObject *str;
111 : 59 : int group_right_1 = 0;
112 : 59 : long attr = 0;
113 : :
114 [ + + + + : 59 : switch (PyTuple_GET_SIZE(args)) {
- ]
115 : 5 : case 1:
116 [ - + ]: 5 : if (!PyArg_ParseTuple(args, "O:addstr", &str)) {
117 : 0 : goto exit;
118 : : }
119 : 5 : break;
120 : 1 : case 2:
121 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Ol:addstr", &str, &attr)) {
122 : 0 : goto exit;
123 : : }
124 : 1 : group_right_1 = 1;
125 : 1 : break;
126 : 51 : case 3:
127 [ - + ]: 51 : if (!PyArg_ParseTuple(args, "iiO:addstr", &y, &x, &str)) {
128 : 0 : goto exit;
129 : : }
130 : 51 : group_left_1 = 1;
131 : 51 : break;
132 : 2 : case 4:
133 [ - + ]: 2 : if (!PyArg_ParseTuple(args, "iiOl:addstr", &y, &x, &str, &attr)) {
134 : 0 : goto exit;
135 : : }
136 : 2 : group_right_1 = 1;
137 : 2 : group_left_1 = 1;
138 : 2 : break;
139 : 0 : default:
140 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.addstr requires 1 to 4 arguments");
141 : 0 : goto exit;
142 : : }
143 : 59 : return_value = _curses_window_addstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
144 : :
145 : 59 : exit:
146 : 59 : return return_value;
147 : : }
148 : :
149 : : PyDoc_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 : :
172 : : static 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 : :
177 : : static PyObject *
178 : 9 : _curses_window_addnstr(PyCursesWindowObject *self, PyObject *args)
179 : : {
180 : 9 : PyObject *return_value = NULL;
181 : 9 : int group_left_1 = 0;
182 : 9 : int y = 0;
183 : 9 : int x = 0;
184 : : PyObject *str;
185 : : int n;
186 : 9 : int group_right_1 = 0;
187 : 9 : long attr = 0;
188 : :
189 [ + + + + : 9 : switch (PyTuple_GET_SIZE(args)) {
- ]
190 : 6 : case 2:
191 [ - + ]: 6 : if (!PyArg_ParseTuple(args, "Oi:addnstr", &str, &n)) {
192 : 0 : goto exit;
193 : : }
194 : 6 : break;
195 : 1 : case 3:
196 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Oil:addnstr", &str, &n, &attr)) {
197 : 0 : goto exit;
198 : : }
199 : 1 : group_right_1 = 1;
200 : 1 : break;
201 : 1 : case 4:
202 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOi:addnstr", &y, &x, &str, &n)) {
203 : 0 : goto exit;
204 : : }
205 : 1 : group_left_1 = 1;
206 : 1 : break;
207 : 1 : case 5:
208 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOil:addnstr", &y, &x, &str, &n, &attr)) {
209 : 0 : goto exit;
210 : : }
211 : 1 : group_right_1 = 1;
212 : 1 : group_left_1 = 1;
213 : 1 : break;
214 : 0 : default:
215 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.addnstr requires 2 to 5 arguments");
216 : 0 : goto exit;
217 : : }
218 : 9 : return_value = _curses_window_addnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
219 : :
220 : 9 : exit:
221 : 9 : return return_value;
222 : : }
223 : :
224 : : PyDoc_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_CAST(_curses_window_bkgd), METH_FASTCALL, _curses_window_bkgd__doc__},
237 : :
238 : : static PyObject *
239 : : _curses_window_bkgd_impl(PyCursesWindowObject *self, PyObject *ch, long attr);
240 : :
241 : : static PyObject *
242 : 2 : _curses_window_bkgd(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
243 : : {
244 : 2 : PyObject *return_value = NULL;
245 : : PyObject *ch;
246 : 2 : long attr = A_NORMAL;
247 : :
248 [ + - - + : 2 : if (!_PyArg_CheckPositional("bkgd", nargs, 1, 2)) {
- - ]
249 : 0 : goto exit;
250 : : }
251 : 2 : ch = args[0];
252 [ + + ]: 2 : if (nargs < 2) {
253 : 1 : goto skip_optional;
254 : : }
255 : 1 : attr = PyLong_AsLong(args[1]);
256 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
257 : 0 : goto exit;
258 : : }
259 : 1 : skip_optional:
260 : 2 : return_value = _curses_window_bkgd_impl(self, ch, attr);
261 : :
262 : 2 : exit:
263 : 2 : return return_value;
264 : : }
265 : :
266 : : PyDoc_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 : :
275 : : static PyObject *
276 : : _curses_window_attroff_impl(PyCursesWindowObject *self, long attr);
277 : :
278 : : static PyObject *
279 : 1 : _curses_window_attroff(PyCursesWindowObject *self, PyObject *arg)
280 : : {
281 : 1 : PyObject *return_value = NULL;
282 : : long attr;
283 : :
284 : 1 : attr = PyLong_AsLong(arg);
285 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
286 : 0 : goto exit;
287 : : }
288 : 1 : return_value = _curses_window_attroff_impl(self, attr);
289 : :
290 : 1 : exit:
291 : 1 : return return_value;
292 : : }
293 : :
294 : : PyDoc_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 : :
303 : : static PyObject *
304 : : _curses_window_attron_impl(PyCursesWindowObject *self, long attr);
305 : :
306 : : static PyObject *
307 : 1 : _curses_window_attron(PyCursesWindowObject *self, PyObject *arg)
308 : : {
309 : 1 : PyObject *return_value = NULL;
310 : : long attr;
311 : :
312 : 1 : attr = PyLong_AsLong(arg);
313 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
314 : 0 : goto exit;
315 : : }
316 : 1 : return_value = _curses_window_attron_impl(self, attr);
317 : :
318 : 1 : exit:
319 : 1 : return return_value;
320 : : }
321 : :
322 : : PyDoc_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 : :
331 : : static PyObject *
332 : : _curses_window_attrset_impl(PyCursesWindowObject *self, long attr);
333 : :
334 : : static PyObject *
335 : 1 : _curses_window_attrset(PyCursesWindowObject *self, PyObject *arg)
336 : : {
337 : 1 : PyObject *return_value = NULL;
338 : : long attr;
339 : :
340 : 1 : attr = PyLong_AsLong(arg);
341 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
342 : 0 : goto exit;
343 : : }
344 : 1 : return_value = _curses_window_attrset_impl(self, attr);
345 : :
346 : 1 : exit:
347 : 1 : return return_value;
348 : : }
349 : :
350 : : PyDoc_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_CAST(_curses_window_bkgdset), METH_FASTCALL, _curses_window_bkgdset__doc__},
363 : :
364 : : static PyObject *
365 : : _curses_window_bkgdset_impl(PyCursesWindowObject *self, PyObject *ch,
366 : : long attr);
367 : :
368 : : static PyObject *
369 : 6 : _curses_window_bkgdset(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
370 : : {
371 : 6 : PyObject *return_value = NULL;
372 : : PyObject *ch;
373 : 6 : long attr = A_NORMAL;
374 : :
375 [ + - - + : 6 : if (!_PyArg_CheckPositional("bkgdset", nargs, 1, 2)) {
- - ]
376 : 0 : goto exit;
377 : : }
378 : 6 : ch = args[0];
379 [ + + ]: 6 : if (nargs < 2) {
380 : 5 : goto skip_optional;
381 : : }
382 : 1 : attr = PyLong_AsLong(args[1]);
383 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
384 : 0 : goto exit;
385 : : }
386 : 1 : skip_optional:
387 : 6 : return_value = _curses_window_bkgdset_impl(self, ch, attr);
388 : :
389 : 6 : exit:
390 : 6 : return return_value;
391 : : }
392 : :
393 : : PyDoc_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_CAST(_curses_window_border), METH_FASTCALL, _curses_window_border__doc__},
426 : :
427 : : static 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 : :
433 : : static PyObject *
434 : 14 : _curses_window_border(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
435 : : {
436 : 14 : PyObject *return_value = NULL;
437 : 14 : PyObject *ls = NULL;
438 : 14 : PyObject *rs = NULL;
439 : 14 : PyObject *ts = NULL;
440 : 14 : PyObject *bs = NULL;
441 : 14 : PyObject *tl = NULL;
442 : 14 : PyObject *tr = NULL;
443 : 14 : PyObject *bl = NULL;
444 : 14 : PyObject *br = NULL;
445 : :
446 [ + - + + : 14 : if (!_PyArg_CheckPositional("border", nargs, 0, 8)) {
+ - ]
447 : 2 : goto exit;
448 : : }
449 [ + + ]: 12 : if (nargs < 1) {
450 : 1 : goto skip_optional;
451 : : }
452 : 11 : ls = args[0];
453 [ + + ]: 11 : if (nargs < 2) {
454 : 1 : goto skip_optional;
455 : : }
456 : 10 : rs = args[1];
457 [ + + ]: 10 : if (nargs < 3) {
458 : 1 : goto skip_optional;
459 : : }
460 : 9 : ts = args[2];
461 [ + + ]: 9 : if (nargs < 4) {
462 : 1 : goto skip_optional;
463 : : }
464 : 8 : bs = args[3];
465 [ + + ]: 8 : if (nargs < 5) {
466 : 1 : goto skip_optional;
467 : : }
468 : 7 : tl = args[4];
469 [ + + ]: 7 : if (nargs < 6) {
470 : 1 : goto skip_optional;
471 : : }
472 : 6 : tr = args[5];
473 [ + + ]: 6 : if (nargs < 7) {
474 : 1 : goto skip_optional;
475 : : }
476 : 5 : bl = args[6];
477 [ + + ]: 5 : if (nargs < 8) {
478 : 1 : goto skip_optional;
479 : : }
480 : 4 : br = args[7];
481 : 12 : skip_optional:
482 : 12 : return_value = _curses_window_border_impl(self, ls, rs, ts, bs, tl, tr, bl, br);
483 : :
484 : 14 : exit:
485 : 14 : return return_value;
486 : : }
487 : :
488 : : PyDoc_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 : :
503 : : static PyObject *
504 : : _curses_window_box_impl(PyCursesWindowObject *self, int group_right_1,
505 : : PyObject *verch, PyObject *horch);
506 : :
507 : : static PyObject *
508 : 6 : _curses_window_box(PyCursesWindowObject *self, PyObject *args)
509 : : {
510 : 6 : PyObject *return_value = NULL;
511 : 6 : int group_right_1 = 0;
512 : 6 : PyObject *verch = _PyLong_GetZero();
513 : 6 : PyObject *horch = _PyLong_GetZero();
514 : :
515 [ + + + ]: 6 : switch (PyTuple_GET_SIZE(args)) {
516 : 1 : case 0:
517 : 1 : break;
518 : 3 : case 2:
519 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "OO:box", &verch, &horch)) {
520 : 0 : goto exit;
521 : : }
522 : 3 : group_right_1 = 1;
523 : 3 : break;
524 : 2 : default:
525 : 2 : PyErr_SetString(PyExc_TypeError, "_curses.window.box requires 0 to 2 arguments");
526 : 2 : goto exit;
527 : : }
528 : 4 : return_value = _curses_window_box_impl(self, group_right_1, verch, horch);
529 : :
530 : 6 : exit:
531 : 6 : return return_value;
532 : : }
533 : :
534 : : PyDoc_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 : :
546 : : static PyObject *
547 : : _curses_window_delch_impl(PyCursesWindowObject *self, int group_right_1,
548 : : int y, int x);
549 : :
550 : : static PyObject *
551 : 2 : _curses_window_delch(PyCursesWindowObject *self, PyObject *args)
552 : : {
553 : 2 : PyObject *return_value = NULL;
554 : 2 : int group_right_1 = 0;
555 : 2 : int y = 0;
556 : 2 : int x = 0;
557 : :
558 [ + + - ]: 2 : switch (PyTuple_GET_SIZE(args)) {
559 : 1 : case 0:
560 : 1 : break;
561 : 1 : case 2:
562 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "ii:delch", &y, &x)) {
563 : 0 : goto exit;
564 : : }
565 : 1 : group_right_1 = 1;
566 : 1 : break;
567 : 0 : default:
568 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.delch requires 0 to 2 arguments");
569 : 0 : goto exit;
570 : : }
571 : 2 : return_value = _curses_window_delch_impl(self, group_right_1, y, x);
572 : :
573 : 2 : exit:
574 : 2 : return return_value;
575 : : }
576 : :
577 : : PyDoc_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 : :
597 : : static PyObject *
598 : : _curses_window_derwin_impl(PyCursesWindowObject *self, int group_left_1,
599 : : int nlines, int ncols, int begin_y, int begin_x);
600 : :
601 : : static PyObject *
602 : 2 : _curses_window_derwin(PyCursesWindowObject *self, PyObject *args)
603 : : {
604 : 2 : PyObject *return_value = NULL;
605 : 2 : int group_left_1 = 0;
606 : 2 : int nlines = 0;
607 : 2 : int ncols = 0;
608 : : int begin_y;
609 : : int begin_x;
610 : :
611 [ + + - ]: 2 : switch (PyTuple_GET_SIZE(args)) {
612 : 1 : case 2:
613 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "ii:derwin", &begin_y, &begin_x)) {
614 : 0 : goto exit;
615 : : }
616 : 1 : break;
617 : 1 : case 4:
618 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiii:derwin", &nlines, &ncols, &begin_y, &begin_x)) {
619 : 0 : goto exit;
620 : : }
621 : 1 : group_left_1 = 1;
622 : 1 : break;
623 : 0 : default:
624 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.derwin requires 2 to 4 arguments");
625 : 0 : goto exit;
626 : : }
627 : 2 : return_value = _curses_window_derwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
628 : :
629 : 2 : exit:
630 : 2 : return return_value;
631 : : }
632 : :
633 : : PyDoc_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_CAST(_curses_window_echochar), METH_FASTCALL, _curses_window_echochar__doc__},
646 : :
647 : : static PyObject *
648 : : _curses_window_echochar_impl(PyCursesWindowObject *self, PyObject *ch,
649 : : long attr);
650 : :
651 : : static PyObject *
652 : 5 : _curses_window_echochar(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
653 : : {
654 : 5 : PyObject *return_value = NULL;
655 : : PyObject *ch;
656 : 5 : long attr = A_NORMAL;
657 : :
658 [ + - - + : 5 : if (!_PyArg_CheckPositional("echochar", nargs, 1, 2)) {
- - ]
659 : 0 : goto exit;
660 : : }
661 : 5 : ch = args[0];
662 [ + + ]: 5 : if (nargs < 2) {
663 : 4 : goto skip_optional;
664 : : }
665 : 1 : attr = PyLong_AsLong(args[1]);
666 [ - + - - ]: 1 : if (attr == -1 && PyErr_Occurred()) {
667 : 0 : goto exit;
668 : : }
669 : 1 : skip_optional:
670 : 5 : return_value = _curses_window_echochar_impl(self, ch, attr);
671 : :
672 : 5 : exit:
673 : 5 : return return_value;
674 : : }
675 : :
676 : : #if defined(NCURSES_MOUSE_VERSION)
677 : :
678 : : PyDoc_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_CAST(_curses_window_enclose), METH_FASTCALL, _curses_window_enclose__doc__},
691 : :
692 : : static PyObject *
693 : : _curses_window_enclose_impl(PyCursesWindowObject *self, int y, int x);
694 : :
695 : : static PyObject *
696 : 6 : _curses_window_enclose(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
697 : : {
698 : 6 : PyObject *return_value = NULL;
699 : : int y;
700 : : int x;
701 : :
702 [ + - - + : 6 : if (!_PyArg_CheckPositional("enclose", nargs, 2, 2)) {
- - ]
703 : 0 : goto exit;
704 : : }
705 : 6 : y = _PyLong_AsInt(args[0]);
706 [ - + - - ]: 6 : if (y == -1 && PyErr_Occurred()) {
707 : 0 : goto exit;
708 : : }
709 : 6 : x = _PyLong_AsInt(args[1]);
710 [ - + - - ]: 6 : if (x == -1 && PyErr_Occurred()) {
711 : 0 : goto exit;
712 : : }
713 : 6 : return_value = _curses_window_enclose_impl(self, y, x);
714 : :
715 : 6 : exit:
716 : 6 : return return_value;
717 : : }
718 : :
719 : : #endif /* defined(NCURSES_MOUSE_VERSION) */
720 : :
721 : : PyDoc_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 : :
730 : : static long
731 : : _curses_window_getbkgd_impl(PyCursesWindowObject *self);
732 : :
733 : : static PyObject *
734 : 8 : _curses_window_getbkgd(PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored))
735 : : {
736 : 8 : PyObject *return_value = NULL;
737 : : long _return_value;
738 : :
739 : 8 : _return_value = _curses_window_getbkgd_impl(self);
740 [ - + - - ]: 8 : if ((_return_value == -1) && PyErr_Occurred()) {
741 : 0 : goto exit;
742 : : }
743 : 8 : return_value = PyLong_FromLong(_return_value);
744 : :
745 : 8 : exit:
746 : 8 : return return_value;
747 : : }
748 : :
749 : : PyDoc_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 : :
765 : : static int
766 : : _curses_window_getch_impl(PyCursesWindowObject *self, int group_right_1,
767 : : int y, int x);
768 : :
769 : : static PyObject *
770 : 5 : _curses_window_getch(PyCursesWindowObject *self, PyObject *args)
771 : : {
772 : 5 : PyObject *return_value = NULL;
773 : 5 : int group_right_1 = 0;
774 : 5 : int y = 0;
775 : 5 : int x = 0;
776 : : int _return_value;
777 : :
778 [ + + - ]: 5 : switch (PyTuple_GET_SIZE(args)) {
779 : 3 : case 0:
780 : 3 : break;
781 : 2 : case 2:
782 [ - + ]: 2 : if (!PyArg_ParseTuple(args, "ii:getch", &y, &x)) {
783 : 0 : goto exit;
784 : : }
785 : 2 : group_right_1 = 1;
786 : 2 : break;
787 : 0 : default:
788 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.getch requires 0 to 2 arguments");
789 : 0 : goto exit;
790 : : }
791 : 5 : _return_value = _curses_window_getch_impl(self, group_right_1, y, x);
792 [ - + - - ]: 5 : if ((_return_value == -1) && PyErr_Occurred()) {
793 : 0 : goto exit;
794 : : }
795 : 5 : return_value = PyLong_FromLong((long)_return_value);
796 : :
797 : 5 : exit:
798 : 5 : return return_value;
799 : : }
800 : :
801 : : PyDoc_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 : :
817 : : static PyObject *
818 : : _curses_window_getkey_impl(PyCursesWindowObject *self, int group_right_1,
819 : : int y, int x);
820 : :
821 : : static PyObject *
822 : 4 : _curses_window_getkey(PyCursesWindowObject *self, PyObject *args)
823 : : {
824 : 4 : PyObject *return_value = NULL;
825 : 4 : int group_right_1 = 0;
826 : 4 : int y = 0;
827 : 4 : int x = 0;
828 : :
829 [ + - - ]: 4 : switch (PyTuple_GET_SIZE(args)) {
830 : 4 : case 0:
831 : 4 : break;
832 : 0 : case 2:
833 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "ii:getkey", &y, &x)) {
834 : 0 : goto exit;
835 : : }
836 : 0 : group_right_1 = 1;
837 : 0 : break;
838 : 0 : default:
839 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.getkey requires 0 to 2 arguments");
840 : 0 : goto exit;
841 : : }
842 : 4 : return_value = _curses_window_getkey_impl(self, group_right_1, y, x);
843 : :
844 : 4 : exit:
845 : 4 : return return_value;
846 : : }
847 : :
848 : : #if defined(HAVE_NCURSESW)
849 : :
850 : : PyDoc_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 : :
865 : : static PyObject *
866 : : _curses_window_get_wch_impl(PyCursesWindowObject *self, int group_right_1,
867 : : int y, int x);
868 : :
869 : : static PyObject *
870 : 8 : _curses_window_get_wch(PyCursesWindowObject *self, PyObject *args)
871 : : {
872 : 8 : PyObject *return_value = NULL;
873 : 8 : int group_right_1 = 0;
874 : 8 : int y = 0;
875 : 8 : int x = 0;
876 : :
877 [ + - - ]: 8 : switch (PyTuple_GET_SIZE(args)) {
878 : 8 : case 0:
879 : 8 : break;
880 : 0 : case 2:
881 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "ii:get_wch", &y, &x)) {
882 : 0 : goto exit;
883 : : }
884 : 0 : group_right_1 = 1;
885 : 0 : break;
886 : 0 : default:
887 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.get_wch requires 0 to 2 arguments");
888 : 0 : goto exit;
889 : : }
890 : 8 : return_value = _curses_window_get_wch_impl(self, group_right_1, y, x);
891 : :
892 : 8 : exit:
893 : 8 : return return_value;
894 : : }
895 : :
896 : : #endif /* defined(HAVE_NCURSESW) */
897 : :
898 : : PyDoc_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 : :
916 : : static 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 : :
921 : : static PyObject *
922 : 6 : _curses_window_hline(PyCursesWindowObject *self, PyObject *args)
923 : : {
924 : 6 : PyObject *return_value = NULL;
925 : 6 : int group_left_1 = 0;
926 : 6 : int y = 0;
927 : 6 : int x = 0;
928 : : PyObject *ch;
929 : : int n;
930 : 6 : int group_right_1 = 0;
931 : 6 : long attr = A_NORMAL;
932 : :
933 [ + + + + : 6 : switch (PyTuple_GET_SIZE(args)) {
- ]
934 : 3 : case 2:
935 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "Oi:hline", &ch, &n)) {
936 : 0 : goto exit;
937 : : }
938 : 3 : break;
939 : 1 : case 3:
940 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Oil:hline", &ch, &n, &attr)) {
941 : 0 : goto exit;
942 : : }
943 : 1 : group_right_1 = 1;
944 : 1 : break;
945 : 1 : case 4:
946 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOi:hline", &y, &x, &ch, &n)) {
947 : 0 : goto exit;
948 : : }
949 : 1 : group_left_1 = 1;
950 : 1 : break;
951 : 1 : case 5:
952 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOil:hline", &y, &x, &ch, &n, &attr)) {
953 : 0 : goto exit;
954 : : }
955 : 1 : group_right_1 = 1;
956 : 1 : group_left_1 = 1;
957 : 1 : break;
958 : 0 : default:
959 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.hline requires 2 to 5 arguments");
960 : 0 : goto exit;
961 : : }
962 : 6 : return_value = _curses_window_hline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
963 : :
964 : 6 : exit:
965 : 6 : return return_value;
966 : : }
967 : :
968 : : PyDoc_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 : :
987 : : static 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 : :
992 : : static PyObject *
993 : 0 : _curses_window_insch(PyCursesWindowObject *self, PyObject *args)
994 : : {
995 : 0 : PyObject *return_value = NULL;
996 : 0 : int group_left_1 = 0;
997 : 0 : int y = 0;
998 : 0 : int x = 0;
999 : : PyObject *ch;
1000 : 0 : int group_right_1 = 0;
1001 : 0 : long attr = A_NORMAL;
1002 : :
1003 [ # # # # : 0 : switch (PyTuple_GET_SIZE(args)) {
# ]
1004 : 0 : case 1:
1005 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "O:insch", &ch)) {
1006 : 0 : goto exit;
1007 : : }
1008 : 0 : break;
1009 : 0 : case 2:
1010 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "Ol:insch", &ch, &attr)) {
1011 : 0 : goto exit;
1012 : : }
1013 : 0 : group_right_1 = 1;
1014 : 0 : break;
1015 : 0 : case 3:
1016 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "iiO:insch", &y, &x, &ch)) {
1017 : 0 : goto exit;
1018 : : }
1019 : 0 : group_left_1 = 1;
1020 : 0 : break;
1021 : 0 : case 4:
1022 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "iiOl:insch", &y, &x, &ch, &attr)) {
1023 : 0 : goto exit;
1024 : : }
1025 : 0 : group_right_1 = 1;
1026 : 0 : group_left_1 = 1;
1027 : 0 : break;
1028 : 0 : default:
1029 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.insch requires 1 to 4 arguments");
1030 : 0 : goto exit;
1031 : : }
1032 : 0 : return_value = _curses_window_insch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
1033 : :
1034 : 0 : exit:
1035 : 0 : return return_value;
1036 : : }
1037 : :
1038 : : PyDoc_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 : :
1052 : : static unsigned long
1053 : : _curses_window_inch_impl(PyCursesWindowObject *self, int group_right_1,
1054 : : int y, int x);
1055 : :
1056 : : static PyObject *
1057 : 64 : _curses_window_inch(PyCursesWindowObject *self, PyObject *args)
1058 : : {
1059 : 64 : PyObject *return_value = NULL;
1060 : 64 : int group_right_1 = 0;
1061 : 64 : int y = 0;
1062 : 64 : int x = 0;
1063 : : unsigned long _return_value;
1064 : :
1065 [ + + - ]: 64 : switch (PyTuple_GET_SIZE(args)) {
1066 : 39 : case 0:
1067 : 39 : break;
1068 : 25 : case 2:
1069 [ - + ]: 25 : if (!PyArg_ParseTuple(args, "ii:inch", &y, &x)) {
1070 : 0 : goto exit;
1071 : : }
1072 : 25 : group_right_1 = 1;
1073 : 25 : break;
1074 : 0 : default:
1075 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.inch requires 0 to 2 arguments");
1076 : 0 : goto exit;
1077 : : }
1078 : 64 : _return_value = _curses_window_inch_impl(self, group_right_1, y, x);
1079 [ - + - - ]: 64 : if ((_return_value == (unsigned long)-1) && PyErr_Occurred()) {
1080 : 0 : goto exit;
1081 : : }
1082 : 64 : return_value = PyLong_FromUnsignedLong(_return_value);
1083 : :
1084 : 64 : exit:
1085 : 64 : return return_value;
1086 : : }
1087 : :
1088 : : PyDoc_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 : :
1110 : : static 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 : :
1115 : : static PyObject *
1116 : 8 : _curses_window_insstr(PyCursesWindowObject *self, PyObject *args)
1117 : : {
1118 : 8 : PyObject *return_value = NULL;
1119 : 8 : int group_left_1 = 0;
1120 : 8 : int y = 0;
1121 : 8 : int x = 0;
1122 : : PyObject *str;
1123 : 8 : int group_right_1 = 0;
1124 : 8 : long attr = 0;
1125 : :
1126 [ + + + + : 8 : switch (PyTuple_GET_SIZE(args)) {
- ]
1127 : 5 : case 1:
1128 [ - + ]: 5 : if (!PyArg_ParseTuple(args, "O:insstr", &str)) {
1129 : 0 : goto exit;
1130 : : }
1131 : 5 : break;
1132 : 1 : case 2:
1133 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Ol:insstr", &str, &attr)) {
1134 : 0 : goto exit;
1135 : : }
1136 : 1 : group_right_1 = 1;
1137 : 1 : break;
1138 : 1 : case 3:
1139 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiO:insstr", &y, &x, &str)) {
1140 : 0 : goto exit;
1141 : : }
1142 : 1 : group_left_1 = 1;
1143 : 1 : break;
1144 : 1 : case 4:
1145 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOl:insstr", &y, &x, &str, &attr)) {
1146 : 0 : goto exit;
1147 : : }
1148 : 1 : group_right_1 = 1;
1149 : 1 : group_left_1 = 1;
1150 : 1 : break;
1151 : 0 : default:
1152 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.insstr requires 1 to 4 arguments");
1153 : 0 : goto exit;
1154 : : }
1155 : 8 : return_value = _curses_window_insstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
1156 : :
1157 : 8 : exit:
1158 : 8 : return return_value;
1159 : : }
1160 : :
1161 : : PyDoc_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 : :
1186 : : static 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 : :
1191 : : static PyObject *
1192 : 9 : _curses_window_insnstr(PyCursesWindowObject *self, PyObject *args)
1193 : : {
1194 : 9 : PyObject *return_value = NULL;
1195 : 9 : int group_left_1 = 0;
1196 : 9 : int y = 0;
1197 : 9 : int x = 0;
1198 : : PyObject *str;
1199 : : int n;
1200 : 9 : int group_right_1 = 0;
1201 : 9 : long attr = 0;
1202 : :
1203 [ + + + + : 9 : switch (PyTuple_GET_SIZE(args)) {
- ]
1204 : 6 : case 2:
1205 [ - + ]: 6 : if (!PyArg_ParseTuple(args, "Oi:insnstr", &str, &n)) {
1206 : 0 : goto exit;
1207 : : }
1208 : 6 : break;
1209 : 1 : case 3:
1210 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Oil:insnstr", &str, &n, &attr)) {
1211 : 0 : goto exit;
1212 : : }
1213 : 1 : group_right_1 = 1;
1214 : 1 : break;
1215 : 1 : case 4:
1216 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOi:insnstr", &y, &x, &str, &n)) {
1217 : 0 : goto exit;
1218 : : }
1219 : 1 : group_left_1 = 1;
1220 : 1 : break;
1221 : 1 : case 5:
1222 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOil:insnstr", &y, &x, &str, &n, &attr)) {
1223 : 0 : goto exit;
1224 : : }
1225 : 1 : group_right_1 = 1;
1226 : 1 : group_left_1 = 1;
1227 : 1 : break;
1228 : 0 : default:
1229 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.insnstr requires 2 to 5 arguments");
1230 : 0 : goto exit;
1231 : : }
1232 : 9 : return_value = _curses_window_insnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
1233 : :
1234 : 9 : exit:
1235 : 9 : return return_value;
1236 : : }
1237 : :
1238 : : PyDoc_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 : :
1252 : : static PyObject *
1253 : : _curses_window_is_linetouched_impl(PyCursesWindowObject *self, int line);
1254 : :
1255 : : static PyObject *
1256 : 3 : _curses_window_is_linetouched(PyCursesWindowObject *self, PyObject *arg)
1257 : : {
1258 : 3 : PyObject *return_value = NULL;
1259 : : int line;
1260 : :
1261 : 3 : line = _PyLong_AsInt(arg);
1262 [ - + - - ]: 3 : if (line == -1 && PyErr_Occurred()) {
1263 : 0 : goto exit;
1264 : : }
1265 : 3 : return_value = _curses_window_is_linetouched_impl(self, line);
1266 : :
1267 : 3 : exit:
1268 : 3 : return return_value;
1269 : : }
1270 : :
1271 : : #if defined(py_is_pad)
1272 : :
1273 : : PyDoc_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 : :
1284 : : static 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 : :
1290 : : static PyObject *
1291 : 1 : _curses_window_noutrefresh(PyCursesWindowObject *self, PyObject *args)
1292 : : {
1293 : 1 : PyObject *return_value = NULL;
1294 : 1 : int group_right_1 = 0;
1295 : 1 : int pminrow = 0;
1296 : 1 : int pmincol = 0;
1297 : 1 : int sminrow = 0;
1298 : 1 : int smincol = 0;
1299 : 1 : int smaxrow = 0;
1300 : 1 : int smaxcol = 0;
1301 : :
1302 [ + - - ]: 1 : switch (PyTuple_GET_SIZE(args)) {
1303 : 1 : case 0:
1304 : 1 : break;
1305 : 0 : case 6:
1306 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "iiiiii:noutrefresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
1307 : 0 : goto exit;
1308 : : }
1309 : 0 : group_right_1 = 1;
1310 : 0 : break;
1311 : 0 : default:
1312 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.noutrefresh requires 0 to 6 arguments");
1313 : 0 : goto exit;
1314 : : }
1315 : 1 : return_value = _curses_window_noutrefresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
1316 : :
1317 : 1 : exit:
1318 : 1 : return return_value;
1319 : : }
1320 : :
1321 : : #endif /* defined(py_is_pad) */
1322 : :
1323 : : #if !defined(py_is_pad)
1324 : :
1325 : : PyDoc_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 : :
1338 : : static PyObject *
1339 : : _curses_window_noutrefresh_impl(PyCursesWindowObject *self);
1340 : :
1341 : : static 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 : :
1349 : : PyDoc_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 : :
1365 : : static 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 : :
1371 : : static PyObject *
1372 : 2 : _curses_window_overlay(PyCursesWindowObject *self, PyObject *args)
1373 : : {
1374 : 2 : PyObject *return_value = NULL;
1375 : : PyCursesWindowObject *destwin;
1376 : 2 : int group_right_1 = 0;
1377 : 2 : int sminrow = 0;
1378 : 2 : int smincol = 0;
1379 : 2 : int dminrow = 0;
1380 : 2 : int dmincol = 0;
1381 : 2 : int dmaxrow = 0;
1382 : 2 : int dmaxcol = 0;
1383 : :
1384 [ + + - ]: 2 : switch (PyTuple_GET_SIZE(args)) {
1385 : 1 : case 1:
1386 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O!:overlay", &PyCursesWindow_Type, &destwin)) {
1387 : 0 : goto exit;
1388 : : }
1389 : 1 : break;
1390 : 1 : case 7:
1391 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O!iiiiii:overlay", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
1392 : 0 : goto exit;
1393 : : }
1394 : 1 : group_right_1 = 1;
1395 : 1 : break;
1396 : 0 : default:
1397 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.overlay requires 1 to 7 arguments");
1398 : 0 : goto exit;
1399 : : }
1400 : 2 : return_value = _curses_window_overlay_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
1401 : :
1402 : 2 : exit:
1403 : 2 : return return_value;
1404 : : }
1405 : :
1406 : : PyDoc_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 : :
1423 : : static 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 : :
1430 : : static PyObject *
1431 : 2 : _curses_window_overwrite(PyCursesWindowObject *self, PyObject *args)
1432 : : {
1433 : 2 : PyObject *return_value = NULL;
1434 : : PyCursesWindowObject *destwin;
1435 : 2 : int group_right_1 = 0;
1436 : 2 : int sminrow = 0;
1437 : 2 : int smincol = 0;
1438 : 2 : int dminrow = 0;
1439 : 2 : int dmincol = 0;
1440 : 2 : int dmaxrow = 0;
1441 : 2 : int dmaxcol = 0;
1442 : :
1443 [ + + - ]: 2 : switch (PyTuple_GET_SIZE(args)) {
1444 : 1 : case 1:
1445 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O!:overwrite", &PyCursesWindow_Type, &destwin)) {
1446 : 0 : goto exit;
1447 : : }
1448 : 1 : break;
1449 : 1 : case 7:
1450 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O!iiiiii:overwrite", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
1451 : 0 : goto exit;
1452 : : }
1453 : 1 : group_right_1 = 1;
1454 : 1 : break;
1455 : 0 : default:
1456 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.overwrite requires 1 to 7 arguments");
1457 : 0 : goto exit;
1458 : : }
1459 : 2 : return_value = _curses_window_overwrite_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
1460 : :
1461 : 2 : exit:
1462 : 2 : return return_value;
1463 : : }
1464 : :
1465 : : PyDoc_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 : :
1476 : : PyDoc_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_CAST(_curses_window_redrawln), METH_FASTCALL, _curses_window_redrawln__doc__},
1491 : :
1492 : : static PyObject *
1493 : : _curses_window_redrawln_impl(PyCursesWindowObject *self, int beg, int num);
1494 : :
1495 : : static PyObject *
1496 : 1 : _curses_window_redrawln(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
1497 : : {
1498 : 1 : PyObject *return_value = NULL;
1499 : : int beg;
1500 : : int num;
1501 : :
1502 [ + - - + : 1 : if (!_PyArg_CheckPositional("redrawln", nargs, 2, 2)) {
- - ]
1503 : 0 : goto exit;
1504 : : }
1505 : 1 : beg = _PyLong_AsInt(args[0]);
1506 [ - + - - ]: 1 : if (beg == -1 && PyErr_Occurred()) {
1507 : 0 : goto exit;
1508 : : }
1509 : 1 : num = _PyLong_AsInt(args[1]);
1510 [ - + - - ]: 1 : if (num == -1 && PyErr_Occurred()) {
1511 : 0 : goto exit;
1512 : : }
1513 : 1 : return_value = _curses_window_redrawln_impl(self, beg, num);
1514 : :
1515 : 1 : exit:
1516 : 1 : return return_value;
1517 : : }
1518 : :
1519 : : PyDoc_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 : :
1538 : : static 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 : :
1543 : : static PyObject *
1544 : 5 : _curses_window_refresh(PyCursesWindowObject *self, PyObject *args)
1545 : : {
1546 : 5 : PyObject *return_value = NULL;
1547 : 5 : int group_right_1 = 0;
1548 : 5 : int pminrow = 0;
1549 : 5 : int pmincol = 0;
1550 : 5 : int sminrow = 0;
1551 : 5 : int smincol = 0;
1552 : 5 : int smaxrow = 0;
1553 : 5 : int smaxcol = 0;
1554 : :
1555 [ + - - ]: 5 : switch (PyTuple_GET_SIZE(args)) {
1556 : 5 : case 0:
1557 : 5 : break;
1558 : 0 : case 6:
1559 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "iiiiii:refresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
1560 : 0 : goto exit;
1561 : : }
1562 : 0 : group_right_1 = 1;
1563 : 0 : break;
1564 : 0 : default:
1565 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.refresh requires 0 to 6 arguments");
1566 : 0 : goto exit;
1567 : : }
1568 : 5 : return_value = _curses_window_refresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
1569 : :
1570 : 5 : exit:
1571 : 5 : return return_value;
1572 : : }
1573 : :
1574 : : PyDoc_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_CAST(_curses_window_setscrreg), METH_FASTCALL, _curses_window_setscrreg__doc__},
1589 : :
1590 : : static PyObject *
1591 : : _curses_window_setscrreg_impl(PyCursesWindowObject *self, int top,
1592 : : int bottom);
1593 : :
1594 : : static PyObject *
1595 : 1 : _curses_window_setscrreg(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
1596 : : {
1597 : 1 : PyObject *return_value = NULL;
1598 : : int top;
1599 : : int bottom;
1600 : :
1601 [ + - - + : 1 : if (!_PyArg_CheckPositional("setscrreg", nargs, 2, 2)) {
- - ]
1602 : 0 : goto exit;
1603 : : }
1604 : 1 : top = _PyLong_AsInt(args[0]);
1605 [ - + - - ]: 1 : if (top == -1 && PyErr_Occurred()) {
1606 : 0 : goto exit;
1607 : : }
1608 : 1 : bottom = _PyLong_AsInt(args[1]);
1609 [ - + - - ]: 1 : if (bottom == -1 && PyErr_Occurred()) {
1610 : 0 : goto exit;
1611 : : }
1612 : 1 : return_value = _curses_window_setscrreg_impl(self, top, bottom);
1613 : :
1614 : 1 : exit:
1615 : 1 : return return_value;
1616 : : }
1617 : :
1618 : : PyDoc_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 : :
1637 : : static PyObject *
1638 : : _curses_window_subwin_impl(PyCursesWindowObject *self, int group_left_1,
1639 : : int nlines, int ncols, int begin_y, int begin_x);
1640 : :
1641 : : static PyObject *
1642 : 5 : _curses_window_subwin(PyCursesWindowObject *self, PyObject *args)
1643 : : {
1644 : 5 : PyObject *return_value = NULL;
1645 : 5 : int group_left_1 = 0;
1646 : 5 : int nlines = 0;
1647 : 5 : int ncols = 0;
1648 : : int begin_y;
1649 : : int begin_x;
1650 : :
1651 [ + + - ]: 5 : switch (PyTuple_GET_SIZE(args)) {
1652 : 1 : case 2:
1653 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "ii:subwin", &begin_y, &begin_x)) {
1654 : 0 : goto exit;
1655 : : }
1656 : 1 : break;
1657 : 4 : case 4:
1658 [ - + ]: 4 : if (!PyArg_ParseTuple(args, "iiii:subwin", &nlines, &ncols, &begin_y, &begin_x)) {
1659 : 0 : goto exit;
1660 : : }
1661 : 4 : group_left_1 = 1;
1662 : 4 : break;
1663 : 0 : default:
1664 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.subwin requires 2 to 4 arguments");
1665 : 0 : goto exit;
1666 : : }
1667 : 5 : return_value = _curses_window_subwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
1668 : :
1669 : 5 : exit:
1670 : 5 : return return_value;
1671 : : }
1672 : :
1673 : : PyDoc_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 : :
1685 : : static PyObject *
1686 : : _curses_window_scroll_impl(PyCursesWindowObject *self, int group_right_1,
1687 : : int lines);
1688 : :
1689 : : static PyObject *
1690 : 3 : _curses_window_scroll(PyCursesWindowObject *self, PyObject *args)
1691 : : {
1692 : 3 : PyObject *return_value = NULL;
1693 : 3 : int group_right_1 = 0;
1694 : 3 : int lines = 1;
1695 : :
1696 [ + + - ]: 3 : switch (PyTuple_GET_SIZE(args)) {
1697 : 1 : case 0:
1698 : 1 : break;
1699 : 2 : case 1:
1700 [ - + ]: 2 : if (!PyArg_ParseTuple(args, "i:scroll", &lines)) {
1701 : 0 : goto exit;
1702 : : }
1703 : 2 : group_right_1 = 1;
1704 : 2 : break;
1705 : 0 : default:
1706 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.scroll requires 0 to 1 arguments");
1707 : 0 : goto exit;
1708 : : }
1709 : 3 : return_value = _curses_window_scroll_impl(self, group_right_1, lines);
1710 : :
1711 : 3 : exit:
1712 : 3 : return return_value;
1713 : : }
1714 : :
1715 : : PyDoc_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 : :
1725 : : static PyObject *
1726 : : _curses_window_touchline_impl(PyCursesWindowObject *self, int start,
1727 : : int count, int group_right_1, int changed);
1728 : :
1729 : : static PyObject *
1730 : 2 : _curses_window_touchline(PyCursesWindowObject *self, PyObject *args)
1731 : : {
1732 : 2 : PyObject *return_value = NULL;
1733 : : int start;
1734 : : int count;
1735 : 2 : int group_right_1 = 0;
1736 : 2 : int changed = 1;
1737 : :
1738 [ + + - ]: 2 : switch (PyTuple_GET_SIZE(args)) {
1739 : 1 : case 2:
1740 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "ii:touchline", &start, &count)) {
1741 : 0 : goto exit;
1742 : : }
1743 : 1 : break;
1744 : 1 : case 3:
1745 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iii:touchline", &start, &count, &changed)) {
1746 : 0 : goto exit;
1747 : : }
1748 : 1 : group_right_1 = 1;
1749 : 1 : break;
1750 : 0 : default:
1751 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.touchline requires 2 to 3 arguments");
1752 : 0 : goto exit;
1753 : : }
1754 : 2 : return_value = _curses_window_touchline_impl(self, start, count, group_right_1, changed);
1755 : :
1756 : 2 : exit:
1757 : 2 : return return_value;
1758 : : }
1759 : :
1760 : : PyDoc_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 : :
1778 : : static 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 : :
1783 : : static PyObject *
1784 : 6 : _curses_window_vline(PyCursesWindowObject *self, PyObject *args)
1785 : : {
1786 : 6 : PyObject *return_value = NULL;
1787 : 6 : int group_left_1 = 0;
1788 : 6 : int y = 0;
1789 : 6 : int x = 0;
1790 : : PyObject *ch;
1791 : : int n;
1792 : 6 : int group_right_1 = 0;
1793 : 6 : long attr = A_NORMAL;
1794 : :
1795 [ + + + + : 6 : switch (PyTuple_GET_SIZE(args)) {
- ]
1796 : 3 : case 2:
1797 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "Oi:vline", &ch, &n)) {
1798 : 0 : goto exit;
1799 : : }
1800 : 3 : break;
1801 : 1 : case 3:
1802 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "Oil:vline", &ch, &n, &attr)) {
1803 : 0 : goto exit;
1804 : : }
1805 : 1 : group_right_1 = 1;
1806 : 1 : break;
1807 : 1 : case 4:
1808 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOi:vline", &y, &x, &ch, &n)) {
1809 : 0 : goto exit;
1810 : : }
1811 : 1 : group_left_1 = 1;
1812 : 1 : break;
1813 : 1 : case 5:
1814 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "iiOil:vline", &y, &x, &ch, &n, &attr)) {
1815 : 0 : goto exit;
1816 : : }
1817 : 1 : group_right_1 = 1;
1818 : 1 : group_left_1 = 1;
1819 : 1 : break;
1820 : 0 : default:
1821 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.window.vline requires 2 to 5 arguments");
1822 : 0 : goto exit;
1823 : : }
1824 : 6 : return_value = _curses_window_vline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
1825 : :
1826 : 6 : exit:
1827 : 6 : return return_value;
1828 : : }
1829 : :
1830 : : #if defined(HAVE_CURSES_FILTER)
1831 : :
1832 : : PyDoc_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 : :
1840 : : static PyObject *
1841 : : _curses_filter_impl(PyObject *module);
1842 : :
1843 : : static PyObject *
1844 : 1 : _curses_filter(PyObject *module, PyObject *Py_UNUSED(ignored))
1845 : : {
1846 : 1 : return _curses_filter_impl(module);
1847 : : }
1848 : :
1849 : : #endif /* defined(HAVE_CURSES_FILTER) */
1850 : :
1851 : : PyDoc_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 : :
1860 : : static PyObject *
1861 : : _curses_baudrate_impl(PyObject *module);
1862 : :
1863 : : static PyObject *
1864 : 1 : _curses_baudrate(PyObject *module, PyObject *Py_UNUSED(ignored))
1865 : : {
1866 : 1 : return _curses_baudrate_impl(module);
1867 : : }
1868 : :
1869 : : PyDoc_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 : :
1878 : : static PyObject *
1879 : : _curses_beep_impl(PyObject *module);
1880 : :
1881 : : static PyObject *
1882 : 1 : _curses_beep(PyObject *module, PyObject *Py_UNUSED(ignored))
1883 : : {
1884 : 1 : return _curses_beep_impl(module);
1885 : : }
1886 : :
1887 : : PyDoc_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 : :
1896 : : static PyObject *
1897 : : _curses_can_change_color_impl(PyObject *module);
1898 : :
1899 : : static PyObject *
1900 : 2 : _curses_can_change_color(PyObject *module, PyObject *Py_UNUSED(ignored))
1901 : : {
1902 : 2 : return _curses_can_change_color_impl(module);
1903 : : }
1904 : :
1905 : : PyDoc_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_CAST(_curses_cbreak), METH_FASTCALL, _curses_cbreak__doc__},
1922 : :
1923 : : static PyObject *
1924 : : _curses_cbreak_impl(PyObject *module, int flag);
1925 : :
1926 : : static PyObject *
1927 : 0 : _curses_cbreak(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1928 : : {
1929 : 0 : PyObject *return_value = NULL;
1930 : 0 : int flag = 1;
1931 : :
1932 [ # # # # : 0 : if (!_PyArg_CheckPositional("cbreak", nargs, 0, 1)) {
# # ]
1933 : 0 : goto exit;
1934 : : }
1935 [ # # ]: 0 : if (nargs < 1) {
1936 : 0 : goto skip_optional;
1937 : : }
1938 : 0 : flag = _PyLong_AsInt(args[0]);
1939 [ # # # # ]: 0 : if (flag == -1 && PyErr_Occurred()) {
1940 : 0 : goto exit;
1941 : : }
1942 : 0 : skip_optional:
1943 : 0 : return_value = _curses_cbreak_impl(module, flag);
1944 : :
1945 : 0 : exit:
1946 : 0 : return return_value;
1947 : : }
1948 : :
1949 : : PyDoc_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 : :
1964 : : static PyObject *
1965 : : _curses_color_content_impl(PyObject *module, int color_number);
1966 : :
1967 : : static PyObject *
1968 : 15 : _curses_color_content(PyObject *module, PyObject *arg)
1969 : : {
1970 : 15 : PyObject *return_value = NULL;
1971 : : int color_number;
1972 : :
1973 [ + + ]: 15 : if (!color_converter(arg, &color_number)) {
1974 : 7 : goto exit;
1975 : : }
1976 : 8 : return_value = _curses_color_content_impl(module, color_number);
1977 : :
1978 : 15 : exit:
1979 : 15 : return return_value;
1980 : : }
1981 : :
1982 : : PyDoc_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 : :
1997 : : static PyObject *
1998 : : _curses_color_pair_impl(PyObject *module, int pair_number);
1999 : :
2000 : : static PyObject *
2001 : 4 : _curses_color_pair(PyObject *module, PyObject *arg)
2002 : : {
2003 : 4 : PyObject *return_value = NULL;
2004 : : int pair_number;
2005 : :
2006 : 4 : pair_number = _PyLong_AsInt(arg);
2007 [ - + - - ]: 4 : if (pair_number == -1 && PyErr_Occurred()) {
2008 : 0 : goto exit;
2009 : : }
2010 : 4 : return_value = _curses_color_pair_impl(module, pair_number);
2011 : :
2012 : 4 : exit:
2013 : 4 : return return_value;
2014 : : }
2015 : :
2016 : : PyDoc_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 : :
2033 : : static PyObject *
2034 : : _curses_curs_set_impl(PyObject *module, int visibility);
2035 : :
2036 : : static PyObject *
2037 : 3 : _curses_curs_set(PyObject *module, PyObject *arg)
2038 : : {
2039 : 3 : PyObject *return_value = NULL;
2040 : : int visibility;
2041 : :
2042 : 3 : visibility = _PyLong_AsInt(arg);
2043 [ - + - - ]: 3 : if (visibility == -1 && PyErr_Occurred()) {
2044 : 0 : goto exit;
2045 : : }
2046 : 3 : return_value = _curses_curs_set_impl(module, visibility);
2047 : :
2048 : 3 : exit:
2049 : 3 : return return_value;
2050 : : }
2051 : :
2052 : : PyDoc_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 : :
2065 : : static PyObject *
2066 : : _curses_def_prog_mode_impl(PyObject *module);
2067 : :
2068 : : static PyObject *
2069 : 0 : _curses_def_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
2070 : : {
2071 : 0 : return _curses_def_prog_mode_impl(module);
2072 : : }
2073 : :
2074 : : PyDoc_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 : :
2087 : : static PyObject *
2088 : : _curses_def_shell_mode_impl(PyObject *module);
2089 : :
2090 : : static PyObject *
2091 : 0 : _curses_def_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
2092 : : {
2093 : 0 : return _curses_def_shell_mode_impl(module);
2094 : : }
2095 : :
2096 : : PyDoc_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 : :
2108 : : static PyObject *
2109 : : _curses_delay_output_impl(PyObject *module, int ms);
2110 : :
2111 : : static PyObject *
2112 : 1 : _curses_delay_output(PyObject *module, PyObject *arg)
2113 : : {
2114 : 1 : PyObject *return_value = NULL;
2115 : : int ms;
2116 : :
2117 : 1 : ms = _PyLong_AsInt(arg);
2118 [ - + - - ]: 1 : if (ms == -1 && PyErr_Occurred()) {
2119 : 0 : goto exit;
2120 : : }
2121 : 1 : return_value = _curses_delay_output_impl(module, ms);
2122 : :
2123 : 1 : exit:
2124 : 1 : return return_value;
2125 : : }
2126 : :
2127 : : PyDoc_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 : :
2136 : : static PyObject *
2137 : : _curses_doupdate_impl(PyObject *module);
2138 : :
2139 : : static PyObject *
2140 : 2 : _curses_doupdate(PyObject *module, PyObject *Py_UNUSED(ignored))
2141 : : {
2142 : 2 : return _curses_doupdate_impl(module);
2143 : : }
2144 : :
2145 : : PyDoc_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_CAST(_curses_echo), METH_FASTCALL, _curses_echo__doc__},
2158 : :
2159 : : static PyObject *
2160 : : _curses_echo_impl(PyObject *module, int flag);
2161 : :
2162 : : static PyObject *
2163 : 4 : _curses_echo(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2164 : : {
2165 : 4 : PyObject *return_value = NULL;
2166 : 4 : int flag = 1;
2167 : :
2168 [ + - - + : 4 : if (!_PyArg_CheckPositional("echo", nargs, 0, 1)) {
- - ]
2169 : 0 : goto exit;
2170 : : }
2171 [ + + ]: 4 : if (nargs < 1) {
2172 : 2 : goto skip_optional;
2173 : : }
2174 : 2 : flag = _PyLong_AsInt(args[0]);
2175 [ - + - - ]: 2 : if (flag == -1 && PyErr_Occurred()) {
2176 : 0 : goto exit;
2177 : : }
2178 : 2 : skip_optional:
2179 : 4 : return_value = _curses_echo_impl(module, flag);
2180 : :
2181 : 4 : exit:
2182 : 4 : return return_value;
2183 : : }
2184 : :
2185 : : PyDoc_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 : :
2194 : : static PyObject *
2195 : : _curses_endwin_impl(PyObject *module);
2196 : :
2197 : : static PyObject *
2198 : 1 : _curses_endwin(PyObject *module, PyObject *Py_UNUSED(ignored))
2199 : : {
2200 : 1 : return _curses_endwin_impl(module);
2201 : : }
2202 : :
2203 : : PyDoc_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 : :
2212 : : static PyObject *
2213 : : _curses_erasechar_impl(PyObject *module);
2214 : :
2215 : : static PyObject *
2216 : 1 : _curses_erasechar(PyObject *module, PyObject *Py_UNUSED(ignored))
2217 : : {
2218 : 1 : return _curses_erasechar_impl(module);
2219 : : }
2220 : :
2221 : : PyDoc_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 : :
2232 : : static PyObject *
2233 : : _curses_flash_impl(PyObject *module);
2234 : :
2235 : : static PyObject *
2236 : 1 : _curses_flash(PyObject *module, PyObject *Py_UNUSED(ignored))
2237 : : {
2238 : 1 : return _curses_flash_impl(module);
2239 : : }
2240 : :
2241 : : PyDoc_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 : :
2253 : : static PyObject *
2254 : : _curses_flushinp_impl(PyObject *module);
2255 : :
2256 : : static PyObject *
2257 : 1 : _curses_flushinp(PyObject *module, PyObject *Py_UNUSED(ignored))
2258 : : {
2259 : 1 : return _curses_flushinp_impl(module);
2260 : : }
2261 : :
2262 : : #if defined(getsyx)
2263 : :
2264 : : PyDoc_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 : :
2275 : : static PyObject *
2276 : : _curses_getsyx_impl(PyObject *module);
2277 : :
2278 : : static PyObject *
2279 : 2 : _curses_getsyx(PyObject *module, PyObject *Py_UNUSED(ignored))
2280 : : {
2281 : 2 : return _curses_getsyx_impl(module);
2282 : : }
2283 : :
2284 : : #endif /* defined(getsyx) */
2285 : :
2286 : : #if defined(NCURSES_MOUSE_VERSION)
2287 : :
2288 : : PyDoc_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 : :
2300 : : static PyObject *
2301 : : _curses_getmouse_impl(PyObject *module);
2302 : :
2303 : : static PyObject *
2304 : 1 : _curses_getmouse(PyObject *module, PyObject *Py_UNUSED(ignored))
2305 : : {
2306 : 1 : return _curses_getmouse_impl(module);
2307 : : }
2308 : :
2309 : : #endif /* defined(NCURSES_MOUSE_VERSION) */
2310 : :
2311 : : #if defined(NCURSES_MOUSE_VERSION)
2312 : :
2313 : : PyDoc_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_CAST(_curses_ungetmouse), METH_FASTCALL, _curses_ungetmouse__doc__},
2323 : :
2324 : : static PyObject *
2325 : : _curses_ungetmouse_impl(PyObject *module, short id, int x, int y, int z,
2326 : : unsigned long bstate);
2327 : :
2328 : : static PyObject *
2329 : 1 : _curses_ungetmouse(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2330 : : {
2331 : 1 : PyObject *return_value = NULL;
2332 : : short id;
2333 : : int x;
2334 : : int y;
2335 : : int z;
2336 : : unsigned long bstate;
2337 : :
2338 [ + - - + : 1 : if (!_PyArg_CheckPositional("ungetmouse", nargs, 5, 5)) {
- - ]
2339 : 0 : goto exit;
2340 : : }
2341 : : {
2342 : 1 : long ival = PyLong_AsLong(args[0]);
2343 [ - + - - ]: 1 : if (ival == -1 && PyErr_Occurred()) {
2344 : 0 : goto exit;
2345 : : }
2346 [ - + ]: 1 : else if (ival < SHRT_MIN) {
2347 : 0 : PyErr_SetString(PyExc_OverflowError,
2348 : : "signed short integer is less than minimum");
2349 : 0 : goto exit;
2350 : : }
2351 [ - + ]: 1 : else if (ival > SHRT_MAX) {
2352 : 0 : PyErr_SetString(PyExc_OverflowError,
2353 : : "signed short integer is greater than maximum");
2354 : 0 : goto exit;
2355 : : }
2356 : : else {
2357 : 1 : id = (short) ival;
2358 : : }
2359 : : }
2360 : 1 : x = _PyLong_AsInt(args[1]);
2361 [ - + - - ]: 1 : if (x == -1 && PyErr_Occurred()) {
2362 : 0 : goto exit;
2363 : : }
2364 : 1 : y = _PyLong_AsInt(args[2]);
2365 [ - + - - ]: 1 : if (y == -1 && PyErr_Occurred()) {
2366 : 0 : goto exit;
2367 : : }
2368 : 1 : z = _PyLong_AsInt(args[3]);
2369 [ - + - - ]: 1 : if (z == -1 && PyErr_Occurred()) {
2370 : 0 : goto exit;
2371 : : }
2372 [ - + ]: 1 : if (!PyLong_Check(args[4])) {
2373 : 0 : _PyArg_BadArgument("ungetmouse", "argument 5", "int", args[4]);
2374 : 0 : goto exit;
2375 : : }
2376 : 1 : bstate = PyLong_AsUnsignedLongMask(args[4]);
2377 : 1 : return_value = _curses_ungetmouse_impl(module, id, x, y, z, bstate);
2378 : :
2379 : 1 : exit:
2380 : 1 : return return_value;
2381 : : }
2382 : :
2383 : : #endif /* defined(NCURSES_MOUSE_VERSION) */
2384 : :
2385 : : PyDoc_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 : :
2397 : : PyDoc_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 : :
2411 : : static PyObject *
2412 : : _curses_halfdelay_impl(PyObject *module, unsigned char tenths);
2413 : :
2414 : : static PyObject *
2415 : 2 : _curses_halfdelay(PyObject *module, PyObject *arg)
2416 : : {
2417 : 2 : PyObject *return_value = NULL;
2418 : : unsigned char tenths;
2419 : :
2420 : : {
2421 : 2 : long ival = PyLong_AsLong(arg);
2422 [ - + - - ]: 2 : if (ival == -1 && PyErr_Occurred()) {
2423 : 0 : goto exit;
2424 : : }
2425 [ - + ]: 2 : else if (ival < 0) {
2426 : 0 : PyErr_SetString(PyExc_OverflowError,
2427 : : "unsigned byte integer is less than minimum");
2428 : 0 : goto exit;
2429 : : }
2430 [ - + ]: 2 : else if (ival > UCHAR_MAX) {
2431 : 0 : PyErr_SetString(PyExc_OverflowError,
2432 : : "unsigned byte integer is greater than maximum");
2433 : 0 : goto exit;
2434 : : }
2435 : : else {
2436 : 2 : tenths = (unsigned char) ival;
2437 : : }
2438 : : }
2439 : 2 : return_value = _curses_halfdelay_impl(module, tenths);
2440 : :
2441 : 2 : exit:
2442 : 2 : return return_value;
2443 : : }
2444 : :
2445 : : PyDoc_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 : :
2454 : : static PyObject *
2455 : : _curses_has_colors_impl(PyObject *module);
2456 : :
2457 : : static PyObject *
2458 : 9 : _curses_has_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
2459 : : {
2460 : 9 : return _curses_has_colors_impl(module);
2461 : : }
2462 : :
2463 : : PyDoc_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 : :
2472 : : static PyObject *
2473 : : _curses_has_ic_impl(PyObject *module);
2474 : :
2475 : : static PyObject *
2476 : 1 : _curses_has_ic(PyObject *module, PyObject *Py_UNUSED(ignored))
2477 : : {
2478 : 1 : return _curses_has_ic_impl(module);
2479 : : }
2480 : :
2481 : : PyDoc_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 : :
2490 : : static PyObject *
2491 : : _curses_has_il_impl(PyObject *module);
2492 : :
2493 : : static PyObject *
2494 : 1 : _curses_has_il(PyObject *module, PyObject *Py_UNUSED(ignored))
2495 : : {
2496 : 1 : return _curses_has_il_impl(module);
2497 : : }
2498 : :
2499 : : #if defined(HAVE_CURSES_HAS_KEY)
2500 : :
2501 : : PyDoc_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 : :
2513 : : static PyObject *
2514 : : _curses_has_key_impl(PyObject *module, int key);
2515 : :
2516 : : static PyObject *
2517 : 1 : _curses_has_key(PyObject *module, PyObject *arg)
2518 : : {
2519 : 1 : PyObject *return_value = NULL;
2520 : : int key;
2521 : :
2522 : 1 : key = _PyLong_AsInt(arg);
2523 [ - + - - ]: 1 : if (key == -1 && PyErr_Occurred()) {
2524 : 0 : goto exit;
2525 : : }
2526 : 1 : return_value = _curses_has_key_impl(module, key);
2527 : :
2528 : 1 : exit:
2529 : 1 : return return_value;
2530 : : }
2531 : :
2532 : : #endif /* defined(HAVE_CURSES_HAS_KEY) */
2533 : :
2534 : : PyDoc_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_CAST(_curses_init_color), METH_FASTCALL, _curses_init_color__doc__},
2555 : :
2556 : : static PyObject *
2557 : : _curses_init_color_impl(PyObject *module, int color_number, short r, short g,
2558 : : short b);
2559 : :
2560 : : static PyObject *
2561 : 20 : _curses_init_color(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2562 : : {
2563 : 20 : PyObject *return_value = NULL;
2564 : : int color_number;
2565 : : short r;
2566 : : short g;
2567 : : short b;
2568 : :
2569 [ + - - + : 20 : if (!_PyArg_CheckPositional("init_color", nargs, 4, 4)) {
- - ]
2570 : 0 : goto exit;
2571 : : }
2572 [ + + ]: 20 : if (!color_converter(args[0], &color_number)) {
2573 : 7 : goto exit;
2574 : : }
2575 [ + + ]: 13 : if (!component_converter(args[1], &r)) {
2576 : 2 : goto exit;
2577 : : }
2578 [ + + ]: 11 : if (!component_converter(args[2], &g)) {
2579 : 2 : goto exit;
2580 : : }
2581 [ + + ]: 9 : if (!component_converter(args[3], &b)) {
2582 : 2 : goto exit;
2583 : : }
2584 : 7 : return_value = _curses_init_color_impl(module, color_number, r, g, b);
2585 : :
2586 : 20 : exit:
2587 : 20 : return return_value;
2588 : : }
2589 : :
2590 : : PyDoc_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_CAST(_curses_init_pair), METH_FASTCALL, _curses_init_pair__doc__},
2608 : :
2609 : : static PyObject *
2610 : : _curses_init_pair_impl(PyObject *module, int pair_number, int fg, int bg);
2611 : :
2612 : : static PyObject *
2613 : 22 : _curses_init_pair(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2614 : : {
2615 : 22 : PyObject *return_value = NULL;
2616 : : int pair_number;
2617 : : int fg;
2618 : : int bg;
2619 : :
2620 [ + - - + : 22 : if (!_PyArg_CheckPositional("init_pair", nargs, 3, 3)) {
- - ]
2621 : 0 : goto exit;
2622 : : }
2623 [ + + ]: 22 : if (!pair_converter(args[0], &pair_number)) {
2624 : 6 : goto exit;
2625 : : }
2626 [ + + ]: 16 : if (!color_allow_default_converter(args[1], &fg)) {
2627 : 4 : goto exit;
2628 : : }
2629 [ + + ]: 12 : if (!color_allow_default_converter(args[2], &bg)) {
2630 : 4 : goto exit;
2631 : : }
2632 : 8 : return_value = _curses_init_pair_impl(module, pair_number, fg, bg);
2633 : :
2634 : 22 : exit:
2635 : 22 : return return_value;
2636 : : }
2637 : :
2638 : : PyDoc_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 : :
2649 : : static PyObject *
2650 : : _curses_initscr_impl(PyObject *module);
2651 : :
2652 : : static PyObject *
2653 : 63 : _curses_initscr(PyObject *module, PyObject *Py_UNUSED(ignored))
2654 : : {
2655 : 63 : return _curses_initscr_impl(module);
2656 : : }
2657 : :
2658 : : PyDoc_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_CAST(_curses_setupterm), METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
2673 : :
2674 : : static PyObject *
2675 : : _curses_setupterm_impl(PyObject *module, const char *term, int fd);
2676 : :
2677 : : static PyObject *
2678 : 65 : _curses_setupterm(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2679 : : {
2680 : 65 : 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 [ + - ]: 65 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
2685 : 65 : const char *term = NULL;
2686 : 65 : int fd = -1;
2687 : :
2688 [ - + - - : 65 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
- - - - ]
2689 [ - + ]: 65 : if (!args) {
2690 : 0 : goto exit;
2691 : : }
2692 [ - + ]: 65 : if (!noptargs) {
2693 : 0 : goto skip_optional_pos;
2694 : : }
2695 [ + + ]: 65 : if (args[0]) {
2696 [ - + ]: 63 : if (args[0] == Py_None) {
2697 : 0 : term = NULL;
2698 : : }
2699 [ + - ]: 63 : else if (PyUnicode_Check(args[0])) {
2700 : : Py_ssize_t term_length;
2701 : 63 : term = PyUnicode_AsUTF8AndSize(args[0], &term_length);
2702 [ - + ]: 63 : if (term == NULL) {
2703 : 0 : goto exit;
2704 : : }
2705 [ - + ]: 63 : if (strlen(term) != (size_t)term_length) {
2706 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2707 : 0 : goto exit;
2708 : : }
2709 : : }
2710 : : else {
2711 : 0 : _PyArg_BadArgument("setupterm", "argument 'term'", "str or None", args[0]);
2712 : 0 : goto exit;
2713 : : }
2714 [ - + ]: 63 : if (!--noptargs) {
2715 : 0 : goto skip_optional_pos;
2716 : : }
2717 : : }
2718 : 65 : fd = _PyLong_AsInt(args[1]);
2719 [ - + - - ]: 65 : if (fd == -1 && PyErr_Occurred()) {
2720 : 0 : goto exit;
2721 : : }
2722 : 65 : skip_optional_pos:
2723 : 65 : return_value = _curses_setupterm_impl(module, term, fd);
2724 : :
2725 : 65 : exit:
2726 : 65 : return return_value;
2727 : : }
2728 : :
2729 : : #if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
2730 : :
2731 : : PyDoc_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 : :
2744 : : static PyObject *
2745 : : _curses_get_escdelay_impl(PyObject *module);
2746 : :
2747 : : static PyObject *
2748 : 2 : _curses_get_escdelay(PyObject *module, PyObject *Py_UNUSED(ignored))
2749 : : {
2750 : 2 : 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 : :
2757 : : PyDoc_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 : :
2773 : : static PyObject *
2774 : : _curses_set_escdelay_impl(PyObject *module, int ms);
2775 : :
2776 : : static PyObject *
2777 : 2 : _curses_set_escdelay(PyObject *module, PyObject *arg)
2778 : : {
2779 : 2 : PyObject *return_value = NULL;
2780 : : int ms;
2781 : :
2782 : 2 : ms = _PyLong_AsInt(arg);
2783 [ - + - - ]: 2 : if (ms == -1 && PyErr_Occurred()) {
2784 : 0 : goto exit;
2785 : : }
2786 : 2 : return_value = _curses_set_escdelay_impl(module, ms);
2787 : :
2788 : 2 : exit:
2789 : 2 : 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 : :
2796 : : PyDoc_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 : :
2808 : : static PyObject *
2809 : : _curses_get_tabsize_impl(PyObject *module);
2810 : :
2811 : : static PyObject *
2812 : 2 : _curses_get_tabsize(PyObject *module, PyObject *Py_UNUSED(ignored))
2813 : : {
2814 : 2 : 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 : :
2821 : : PyDoc_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 : :
2836 : : static PyObject *
2837 : : _curses_set_tabsize_impl(PyObject *module, int size);
2838 : :
2839 : : static PyObject *
2840 : 2 : _curses_set_tabsize(PyObject *module, PyObject *arg)
2841 : : {
2842 : 2 : PyObject *return_value = NULL;
2843 : : int size;
2844 : :
2845 : 2 : size = _PyLong_AsInt(arg);
2846 [ - + - - ]: 2 : if (size == -1 && PyErr_Occurred()) {
2847 : 0 : goto exit;
2848 : : }
2849 : 2 : return_value = _curses_set_tabsize_impl(module, size);
2850 : :
2851 : 2 : exit:
2852 : 2 : return return_value;
2853 : : }
2854 : :
2855 : : #endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
2856 : :
2857 : : PyDoc_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 : :
2865 : : static PyObject *
2866 : : _curses_intrflush_impl(PyObject *module, int flag);
2867 : :
2868 : : static PyObject *
2869 : 0 : _curses_intrflush(PyObject *module, PyObject *arg)
2870 : : {
2871 : 0 : PyObject *return_value = NULL;
2872 : : int flag;
2873 : :
2874 : 0 : flag = _PyLong_AsInt(arg);
2875 [ # # # # ]: 0 : if (flag == -1 && PyErr_Occurred()) {
2876 : 0 : goto exit;
2877 : : }
2878 : 0 : return_value = _curses_intrflush_impl(module, flag);
2879 : :
2880 : 0 : exit:
2881 : 0 : return return_value;
2882 : : }
2883 : :
2884 : : PyDoc_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 : :
2893 : : static PyObject *
2894 : : _curses_isendwin_impl(PyObject *module);
2895 : :
2896 : : static PyObject *
2897 : 1 : _curses_isendwin(PyObject *module, PyObject *Py_UNUSED(ignored))
2898 : : {
2899 : 1 : return _curses_isendwin_impl(module);
2900 : : }
2901 : :
2902 : : #if defined(HAVE_CURSES_IS_TERM_RESIZED)
2903 : :
2904 : : PyDoc_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_CAST(_curses_is_term_resized), METH_FASTCALL, _curses_is_term_resized__doc__},
2917 : :
2918 : : static PyObject *
2919 : : _curses_is_term_resized_impl(PyObject *module, int nlines, int ncols);
2920 : :
2921 : : static PyObject *
2922 : 2 : _curses_is_term_resized(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2923 : : {
2924 : 2 : PyObject *return_value = NULL;
2925 : : int nlines;
2926 : : int ncols;
2927 : :
2928 [ + - - + : 2 : if (!_PyArg_CheckPositional("is_term_resized", nargs, 2, 2)) {
- - ]
2929 : 0 : goto exit;
2930 : : }
2931 : 2 : nlines = _PyLong_AsInt(args[0]);
2932 [ - + - - ]: 2 : if (nlines == -1 && PyErr_Occurred()) {
2933 : 0 : goto exit;
2934 : : }
2935 : 2 : ncols = _PyLong_AsInt(args[1]);
2936 [ - + - - ]: 2 : if (ncols == -1 && PyErr_Occurred()) {
2937 : 0 : goto exit;
2938 : : }
2939 : 2 : return_value = _curses_is_term_resized_impl(module, nlines, ncols);
2940 : :
2941 : 2 : exit:
2942 : 2 : return return_value;
2943 : : }
2944 : :
2945 : : #endif /* defined(HAVE_CURSES_IS_TERM_RESIZED) */
2946 : :
2947 : : PyDoc_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 : :
2959 : : static PyObject *
2960 : : _curses_keyname_impl(PyObject *module, int key);
2961 : :
2962 : : static PyObject *
2963 : 6 : _curses_keyname(PyObject *module, PyObject *arg)
2964 : : {
2965 : 6 : PyObject *return_value = NULL;
2966 : : int key;
2967 : :
2968 : 6 : key = _PyLong_AsInt(arg);
2969 [ + + - + ]: 6 : if (key == -1 && PyErr_Occurred()) {
2970 : 0 : goto exit;
2971 : : }
2972 : 6 : return_value = _curses_keyname_impl(module, key);
2973 : :
2974 : 6 : exit:
2975 : 6 : return return_value;
2976 : : }
2977 : :
2978 : : PyDoc_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 : :
2987 : : static PyObject *
2988 : : _curses_killchar_impl(PyObject *module);
2989 : :
2990 : : static PyObject *
2991 : 1 : _curses_killchar(PyObject *module, PyObject *Py_UNUSED(ignored))
2992 : : {
2993 : 1 : return _curses_killchar_impl(module);
2994 : : }
2995 : :
2996 : : PyDoc_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 : :
3008 : : static PyObject *
3009 : : _curses_longname_impl(PyObject *module);
3010 : :
3011 : : static PyObject *
3012 : 1 : _curses_longname(PyObject *module, PyObject *Py_UNUSED(ignored))
3013 : : {
3014 : 1 : return _curses_longname_impl(module);
3015 : : }
3016 : :
3017 : : PyDoc_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 : :
3029 : : static PyObject *
3030 : : _curses_meta_impl(PyObject *module, int yes);
3031 : :
3032 : : static PyObject *
3033 : 2 : _curses_meta(PyObject *module, PyObject *arg)
3034 : : {
3035 : 2 : PyObject *return_value = NULL;
3036 : : int yes;
3037 : :
3038 : 2 : yes = _PyLong_AsInt(arg);
3039 [ - + - - ]: 2 : if (yes == -1 && PyErr_Occurred()) {
3040 : 0 : goto exit;
3041 : : }
3042 : 2 : return_value = _curses_meta_impl(module, yes);
3043 : :
3044 : 2 : exit:
3045 : 2 : return return_value;
3046 : : }
3047 : :
3048 : : #if defined(NCURSES_MOUSE_VERSION)
3049 : :
3050 : : PyDoc_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 : :
3066 : : static PyObject *
3067 : : _curses_mouseinterval_impl(PyObject *module, int interval);
3068 : :
3069 : : static PyObject *
3070 : 1 : _curses_mouseinterval(PyObject *module, PyObject *arg)
3071 : : {
3072 : 1 : PyObject *return_value = NULL;
3073 : : int interval;
3074 : :
3075 : 1 : interval = _PyLong_AsInt(arg);
3076 [ - + - - ]: 1 : if (interval == -1 && PyErr_Occurred()) {
3077 : 0 : goto exit;
3078 : : }
3079 : 1 : return_value = _curses_mouseinterval_impl(module, interval);
3080 : :
3081 : 1 : exit:
3082 : 1 : return return_value;
3083 : : }
3084 : :
3085 : : #endif /* defined(NCURSES_MOUSE_VERSION) */
3086 : :
3087 : : #if defined(NCURSES_MOUSE_VERSION)
3088 : :
3089 : : PyDoc_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 : :
3103 : : static PyObject *
3104 : : _curses_mousemask_impl(PyObject *module, unsigned long newmask);
3105 : :
3106 : : static PyObject *
3107 : 1 : _curses_mousemask(PyObject *module, PyObject *arg)
3108 : : {
3109 : 1 : PyObject *return_value = NULL;
3110 : : unsigned long newmask;
3111 : :
3112 [ - + ]: 1 : if (!PyLong_Check(arg)) {
3113 : 0 : _PyArg_BadArgument("mousemask", "argument", "int", arg);
3114 : 0 : goto exit;
3115 : : }
3116 : 1 : newmask = PyLong_AsUnsignedLongMask(arg);
3117 : 1 : return_value = _curses_mousemask_impl(module, newmask);
3118 : :
3119 : 1 : exit:
3120 : 1 : return return_value;
3121 : : }
3122 : :
3123 : : #endif /* defined(NCURSES_MOUSE_VERSION) */
3124 : :
3125 : : PyDoc_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 : :
3137 : : static PyObject *
3138 : : _curses_napms_impl(PyObject *module, int ms);
3139 : :
3140 : : static PyObject *
3141 : 1 : _curses_napms(PyObject *module, PyObject *arg)
3142 : : {
3143 : 1 : PyObject *return_value = NULL;
3144 : : int ms;
3145 : :
3146 : 1 : ms = _PyLong_AsInt(arg);
3147 [ - + - - ]: 1 : if (ms == -1 && PyErr_Occurred()) {
3148 : 0 : goto exit;
3149 : : }
3150 : 1 : return_value = _curses_napms_impl(module, ms);
3151 : :
3152 : 1 : exit:
3153 : 1 : return return_value;
3154 : : }
3155 : :
3156 : : PyDoc_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_CAST(_curses_newpad), METH_FASTCALL, _curses_newpad__doc__},
3169 : :
3170 : : static PyObject *
3171 : : _curses_newpad_impl(PyObject *module, int nlines, int ncols);
3172 : :
3173 : : static PyObject *
3174 : 1 : _curses_newpad(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3175 : : {
3176 : 1 : PyObject *return_value = NULL;
3177 : : int nlines;
3178 : : int ncols;
3179 : :
3180 [ + - - + : 1 : if (!_PyArg_CheckPositional("newpad", nargs, 2, 2)) {
- - ]
3181 : 0 : goto exit;
3182 : : }
3183 : 1 : nlines = _PyLong_AsInt(args[0]);
3184 [ - + - - ]: 1 : if (nlines == -1 && PyErr_Occurred()) {
3185 : 0 : goto exit;
3186 : : }
3187 : 1 : ncols = _PyLong_AsInt(args[1]);
3188 [ - + - - ]: 1 : if (ncols == -1 && PyErr_Occurred()) {
3189 : 0 : goto exit;
3190 : : }
3191 : 1 : return_value = _curses_newpad_impl(module, nlines, ncols);
3192 : :
3193 : 1 : exit:
3194 : 1 : return return_value;
3195 : : }
3196 : :
3197 : : PyDoc_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 : :
3216 : : static PyObject *
3217 : : _curses_newwin_impl(PyObject *module, int nlines, int ncols,
3218 : : int group_right_1, int begin_y, int begin_x);
3219 : :
3220 : : static PyObject *
3221 : 22 : _curses_newwin(PyObject *module, PyObject *args)
3222 : : {
3223 : 22 : PyObject *return_value = NULL;
3224 : : int nlines;
3225 : : int ncols;
3226 : 22 : int group_right_1 = 0;
3227 : 22 : int begin_y = 0;
3228 : 22 : int begin_x = 0;
3229 : :
3230 [ + + - ]: 22 : switch (PyTuple_GET_SIZE(args)) {
3231 : 5 : case 2:
3232 [ - + ]: 5 : if (!PyArg_ParseTuple(args, "ii:newwin", &nlines, &ncols)) {
3233 : 0 : goto exit;
3234 : : }
3235 : 5 : break;
3236 : 17 : case 4:
3237 [ - + ]: 17 : if (!PyArg_ParseTuple(args, "iiii:newwin", &nlines, &ncols, &begin_y, &begin_x)) {
3238 : 0 : goto exit;
3239 : : }
3240 : 17 : group_right_1 = 1;
3241 : 17 : break;
3242 : 0 : default:
3243 : 0 : PyErr_SetString(PyExc_TypeError, "_curses.newwin requires 2 to 4 arguments");
3244 : 0 : goto exit;
3245 : : }
3246 : 22 : return_value = _curses_newwin_impl(module, nlines, ncols, group_right_1, begin_y, begin_x);
3247 : :
3248 : 22 : exit:
3249 : 22 : return return_value;
3250 : : }
3251 : :
3252 : : PyDoc_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_CAST(_curses_nl), METH_FASTCALL, _curses_nl__doc__},
3266 : :
3267 : : static PyObject *
3268 : : _curses_nl_impl(PyObject *module, int flag);
3269 : :
3270 : : static PyObject *
3271 : 3 : _curses_nl(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3272 : : {
3273 : 3 : PyObject *return_value = NULL;
3274 : 3 : int flag = 1;
3275 : :
3276 [ + - - + : 3 : if (!_PyArg_CheckPositional("nl", nargs, 0, 1)) {
- - ]
3277 : 0 : goto exit;
3278 : : }
3279 [ + + ]: 3 : if (nargs < 1) {
3280 : 1 : goto skip_optional;
3281 : : }
3282 : 2 : flag = _PyLong_AsInt(args[0]);
3283 [ - + - - ]: 2 : if (flag == -1 && PyErr_Occurred()) {
3284 : 0 : goto exit;
3285 : : }
3286 : 2 : skip_optional:
3287 : 3 : return_value = _curses_nl_impl(module, flag);
3288 : :
3289 : 3 : exit:
3290 : 3 : return return_value;
3291 : : }
3292 : :
3293 : : PyDoc_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 : :
3304 : : static PyObject *
3305 : : _curses_nocbreak_impl(PyObject *module);
3306 : :
3307 : : static PyObject *
3308 : 0 : _curses_nocbreak(PyObject *module, PyObject *Py_UNUSED(ignored))
3309 : : {
3310 : 0 : return _curses_nocbreak_impl(module);
3311 : : }
3312 : :
3313 : : PyDoc_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 : :
3324 : : static PyObject *
3325 : : _curses_noecho_impl(PyObject *module);
3326 : :
3327 : : static PyObject *
3328 : 2 : _curses_noecho(PyObject *module, PyObject *Py_UNUSED(ignored))
3329 : : {
3330 : 2 : return _curses_noecho_impl(module);
3331 : : }
3332 : :
3333 : : PyDoc_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 : :
3345 : : static PyObject *
3346 : : _curses_nonl_impl(PyObject *module);
3347 : :
3348 : : static PyObject *
3349 : 1 : _curses_nonl(PyObject *module, PyObject *Py_UNUSED(ignored))
3350 : : {
3351 : 1 : return _curses_nonl_impl(module);
3352 : : }
3353 : :
3354 : : PyDoc_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 : :
3366 : : static PyObject *
3367 : : _curses_noqiflush_impl(PyObject *module);
3368 : :
3369 : : static PyObject *
3370 : 1 : _curses_noqiflush(PyObject *module, PyObject *Py_UNUSED(ignored))
3371 : : {
3372 : 1 : return _curses_noqiflush_impl(module);
3373 : : }
3374 : :
3375 : : PyDoc_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 : :
3386 : : static PyObject *
3387 : : _curses_noraw_impl(PyObject *module);
3388 : :
3389 : : static PyObject *
3390 : 0 : _curses_noraw(PyObject *module, PyObject *Py_UNUSED(ignored))
3391 : : {
3392 : 0 : return _curses_noraw_impl(module);
3393 : : }
3394 : :
3395 : : PyDoc_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 : :
3407 : : static PyObject *
3408 : : _curses_pair_content_impl(PyObject *module, int pair_number);
3409 : :
3410 : : static PyObject *
3411 : 17 : _curses_pair_content(PyObject *module, PyObject *arg)
3412 : : {
3413 : 17 : PyObject *return_value = NULL;
3414 : : int pair_number;
3415 : :
3416 [ + + ]: 17 : if (!pair_converter(arg, &pair_number)) {
3417 : 6 : goto exit;
3418 : : }
3419 : 11 : return_value = _curses_pair_content_impl(module, pair_number);
3420 : :
3421 : 17 : exit:
3422 : 17 : return return_value;
3423 : : }
3424 : :
3425 : : PyDoc_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 : :
3436 : : static PyObject *
3437 : : _curses_pair_number_impl(PyObject *module, int attr);
3438 : :
3439 : : static PyObject *
3440 : 7 : _curses_pair_number(PyObject *module, PyObject *arg)
3441 : : {
3442 : 7 : PyObject *return_value = NULL;
3443 : : int attr;
3444 : :
3445 : 7 : attr = _PyLong_AsInt(arg);
3446 [ - + - - ]: 7 : if (attr == -1 && PyErr_Occurred()) {
3447 : 0 : goto exit;
3448 : : }
3449 : 7 : return_value = _curses_pair_number_impl(module, attr);
3450 : :
3451 : 7 : exit:
3452 : 7 : return return_value;
3453 : : }
3454 : :
3455 : : PyDoc_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 : :
3466 : : static PyObject *
3467 : : _curses_putp_impl(PyObject *module, const char *string);
3468 : :
3469 : : static PyObject *
3470 : 2 : _curses_putp(PyObject *module, PyObject *arg)
3471 : : {
3472 : 2 : PyObject *return_value = NULL;
3473 : : const char *string;
3474 : :
3475 [ - + ]: 2 : if (!PyArg_Parse(arg, "y:putp", &string)) {
3476 : 0 : goto exit;
3477 : : }
3478 : 2 : return_value = _curses_putp_impl(module, string);
3479 : :
3480 : 2 : exit:
3481 : 2 : return return_value;
3482 : : }
3483 : :
3484 : : PyDoc_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_CAST(_curses_qiflush), METH_FASTCALL, _curses_qiflush__doc__},
3498 : :
3499 : : static PyObject *
3500 : : _curses_qiflush_impl(PyObject *module, int flag);
3501 : :
3502 : : static PyObject *
3503 : 3 : _curses_qiflush(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3504 : : {
3505 : 3 : PyObject *return_value = NULL;
3506 : 3 : int flag = 1;
3507 : :
3508 [ + - - + : 3 : if (!_PyArg_CheckPositional("qiflush", nargs, 0, 1)) {
- - ]
3509 : 0 : goto exit;
3510 : : }
3511 [ + + ]: 3 : if (nargs < 1) {
3512 : 1 : goto skip_optional;
3513 : : }
3514 : 2 : flag = _PyLong_AsInt(args[0]);
3515 [ - + - - ]: 2 : if (flag == -1 && PyErr_Occurred()) {
3516 : 0 : goto exit;
3517 : : }
3518 : 2 : skip_optional:
3519 : 3 : return_value = _curses_qiflush_impl(module, flag);
3520 : :
3521 : 3 : exit:
3522 : 3 : return return_value;
3523 : : }
3524 : :
3525 : : #if (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM))
3526 : :
3527 : : PyDoc_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 : :
3535 : : static PyObject *
3536 : : _curses_update_lines_cols_impl(PyObject *module);
3537 : :
3538 : : static PyObject *
3539 : 4 : _curses_update_lines_cols(PyObject *module, PyObject *Py_UNUSED(ignored))
3540 : : {
3541 : 4 : return _curses_update_lines_cols_impl(module);
3542 : : }
3543 : :
3544 : : #endif /* (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM)) */
3545 : :
3546 : : PyDoc_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_CAST(_curses_raw), METH_FASTCALL, _curses_raw__doc__},
3561 : :
3562 : : static PyObject *
3563 : : _curses_raw_impl(PyObject *module, int flag);
3564 : :
3565 : : static PyObject *
3566 : 0 : _curses_raw(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3567 : : {
3568 : 0 : PyObject *return_value = NULL;
3569 : 0 : int flag = 1;
3570 : :
3571 [ # # # # : 0 : if (!_PyArg_CheckPositional("raw", nargs, 0, 1)) {
# # ]
3572 : 0 : goto exit;
3573 : : }
3574 [ # # ]: 0 : if (nargs < 1) {
3575 : 0 : goto skip_optional;
3576 : : }
3577 : 0 : flag = _PyLong_AsInt(args[0]);
3578 [ # # # # ]: 0 : if (flag == -1 && PyErr_Occurred()) {
3579 : 0 : goto exit;
3580 : : }
3581 : 0 : skip_optional:
3582 : 0 : return_value = _curses_raw_impl(module, flag);
3583 : :
3584 : 0 : exit:
3585 : 0 : return return_value;
3586 : : }
3587 : :
3588 : : PyDoc_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 : :
3597 : : static PyObject *
3598 : : _curses_reset_prog_mode_impl(PyObject *module);
3599 : :
3600 : : static PyObject *
3601 : 0 : _curses_reset_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
3602 : : {
3603 : 0 : return _curses_reset_prog_mode_impl(module);
3604 : : }
3605 : :
3606 : : PyDoc_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 : :
3615 : : static PyObject *
3616 : : _curses_reset_shell_mode_impl(PyObject *module);
3617 : :
3618 : : static PyObject *
3619 : 0 : _curses_reset_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
3620 : : {
3621 : 0 : return _curses_reset_shell_mode_impl(module);
3622 : : }
3623 : :
3624 : : PyDoc_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 : :
3633 : : static PyObject *
3634 : : _curses_resetty_impl(PyObject *module);
3635 : :
3636 : : static PyObject *
3637 : 1 : _curses_resetty(PyObject *module, PyObject *Py_UNUSED(ignored))
3638 : : {
3639 : 1 : return _curses_resetty_impl(module);
3640 : : }
3641 : :
3642 : : #if defined(HAVE_CURSES_RESIZETERM)
3643 : :
3644 : : PyDoc_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_CAST(_curses_resizeterm), METH_FASTCALL, _curses_resizeterm__doc__},
3660 : :
3661 : : static PyObject *
3662 : : _curses_resizeterm_impl(PyObject *module, int nlines, int ncols);
3663 : :
3664 : : static PyObject *
3665 : 2 : _curses_resizeterm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3666 : : {
3667 : 2 : PyObject *return_value = NULL;
3668 : : int nlines;
3669 : : int ncols;
3670 : :
3671 [ + - - + : 2 : if (!_PyArg_CheckPositional("resizeterm", nargs, 2, 2)) {
- - ]
3672 : 0 : goto exit;
3673 : : }
3674 : 2 : nlines = _PyLong_AsInt(args[0]);
3675 [ - + - - ]: 2 : if (nlines == -1 && PyErr_Occurred()) {
3676 : 0 : goto exit;
3677 : : }
3678 : 2 : ncols = _PyLong_AsInt(args[1]);
3679 [ - + - - ]: 2 : if (ncols == -1 && PyErr_Occurred()) {
3680 : 0 : goto exit;
3681 : : }
3682 : 2 : return_value = _curses_resizeterm_impl(module, nlines, ncols);
3683 : :
3684 : 2 : exit:
3685 : 2 : return return_value;
3686 : : }
3687 : :
3688 : : #endif /* defined(HAVE_CURSES_RESIZETERM) */
3689 : :
3690 : : #if defined(HAVE_CURSES_RESIZE_TERM)
3691 : :
3692 : : PyDoc_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_CAST(_curses_resize_term), METH_FASTCALL, _curses_resize_term__doc__},
3711 : :
3712 : : static PyObject *
3713 : : _curses_resize_term_impl(PyObject *module, int nlines, int ncols);
3714 : :
3715 : : static PyObject *
3716 : 2 : _curses_resize_term(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3717 : : {
3718 : 2 : PyObject *return_value = NULL;
3719 : : int nlines;
3720 : : int ncols;
3721 : :
3722 [ + - - + : 2 : if (!_PyArg_CheckPositional("resize_term", nargs, 2, 2)) {
- - ]
3723 : 0 : goto exit;
3724 : : }
3725 : 2 : nlines = _PyLong_AsInt(args[0]);
3726 [ - + - - ]: 2 : if (nlines == -1 && PyErr_Occurred()) {
3727 : 0 : goto exit;
3728 : : }
3729 : 2 : ncols = _PyLong_AsInt(args[1]);
3730 [ - + - - ]: 2 : if (ncols == -1 && PyErr_Occurred()) {
3731 : 0 : goto exit;
3732 : : }
3733 : 2 : return_value = _curses_resize_term_impl(module, nlines, ncols);
3734 : :
3735 : 2 : exit:
3736 : 2 : return return_value;
3737 : : }
3738 : :
3739 : : #endif /* defined(HAVE_CURSES_RESIZE_TERM) */
3740 : :
3741 : : PyDoc_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 : :
3750 : : static PyObject *
3751 : : _curses_savetty_impl(PyObject *module);
3752 : :
3753 : : static PyObject *
3754 : 1 : _curses_savetty(PyObject *module, PyObject *Py_UNUSED(ignored))
3755 : : {
3756 : 1 : return _curses_savetty_impl(module);
3757 : : }
3758 : :
3759 : : #if defined(getsyx)
3760 : :
3761 : : PyDoc_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_CAST(_curses_setsyx), METH_FASTCALL, _curses_setsyx__doc__},
3776 : :
3777 : : static PyObject *
3778 : : _curses_setsyx_impl(PyObject *module, int y, int x);
3779 : :
3780 : : static PyObject *
3781 : 1 : _curses_setsyx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3782 : : {
3783 : 1 : PyObject *return_value = NULL;
3784 : : int y;
3785 : : int x;
3786 : :
3787 [ + - - + : 1 : if (!_PyArg_CheckPositional("setsyx", nargs, 2, 2)) {
- - ]
3788 : 0 : goto exit;
3789 : : }
3790 : 1 : y = _PyLong_AsInt(args[0]);
3791 [ - + - - ]: 1 : if (y == -1 && PyErr_Occurred()) {
3792 : 0 : goto exit;
3793 : : }
3794 : 1 : x = _PyLong_AsInt(args[1]);
3795 [ - + - - ]: 1 : if (x == -1 && PyErr_Occurred()) {
3796 : 0 : goto exit;
3797 : : }
3798 : 1 : return_value = _curses_setsyx_impl(module, y, x);
3799 : :
3800 : 1 : exit:
3801 : 1 : return return_value;
3802 : : }
3803 : :
3804 : : #endif /* defined(getsyx) */
3805 : :
3806 : : PyDoc_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 : :
3822 : : static PyObject *
3823 : : _curses_start_color_impl(PyObject *module);
3824 : :
3825 : : static PyObject *
3826 : 8 : _curses_start_color(PyObject *module, PyObject *Py_UNUSED(ignored))
3827 : : {
3828 : 8 : return _curses_start_color_impl(module);
3829 : : }
3830 : :
3831 : : PyDoc_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 : :
3840 : : static PyObject *
3841 : : _curses_termattrs_impl(PyObject *module);
3842 : :
3843 : : static PyObject *
3844 : 1 : _curses_termattrs(PyObject *module, PyObject *Py_UNUSED(ignored))
3845 : : {
3846 : 1 : return _curses_termattrs_impl(module);
3847 : : }
3848 : :
3849 : : PyDoc_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 : :
3858 : : static PyObject *
3859 : : _curses_termname_impl(PyObject *module);
3860 : :
3861 : : static PyObject *
3862 : 1 : _curses_termname(PyObject *module, PyObject *Py_UNUSED(ignored))
3863 : : {
3864 : 1 : return _curses_termname_impl(module);
3865 : : }
3866 : :
3867 : : PyDoc_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 : :
3882 : : static PyObject *
3883 : : _curses_tigetflag_impl(PyObject *module, const char *capname);
3884 : :
3885 : : static PyObject *
3886 : 3 : _curses_tigetflag(PyObject *module, PyObject *arg)
3887 : : {
3888 : 3 : PyObject *return_value = NULL;
3889 : : const char *capname;
3890 : :
3891 [ - + ]: 3 : if (!PyUnicode_Check(arg)) {
3892 : 0 : _PyArg_BadArgument("tigetflag", "argument", "str", arg);
3893 : 0 : goto exit;
3894 : : }
3895 : : Py_ssize_t capname_length;
3896 : 3 : capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3897 [ - + ]: 3 : if (capname == NULL) {
3898 : 0 : goto exit;
3899 : : }
3900 [ - + ]: 3 : if (strlen(capname) != (size_t)capname_length) {
3901 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
3902 : 0 : goto exit;
3903 : : }
3904 : 3 : return_value = _curses_tigetflag_impl(module, capname);
3905 : :
3906 : 3 : exit:
3907 : 3 : return return_value;
3908 : : }
3909 : :
3910 : : PyDoc_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 : :
3925 : : static PyObject *
3926 : : _curses_tigetnum_impl(PyObject *module, const char *capname);
3927 : :
3928 : : static PyObject *
3929 : 3 : _curses_tigetnum(PyObject *module, PyObject *arg)
3930 : : {
3931 : 3 : PyObject *return_value = NULL;
3932 : : const char *capname;
3933 : :
3934 [ - + ]: 3 : if (!PyUnicode_Check(arg)) {
3935 : 0 : _PyArg_BadArgument("tigetnum", "argument", "str", arg);
3936 : 0 : goto exit;
3937 : : }
3938 : : Py_ssize_t capname_length;
3939 : 3 : capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3940 [ - + ]: 3 : if (capname == NULL) {
3941 : 0 : goto exit;
3942 : : }
3943 [ - + ]: 3 : if (strlen(capname) != (size_t)capname_length) {
3944 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
3945 : 0 : goto exit;
3946 : : }
3947 : 3 : return_value = _curses_tigetnum_impl(module, capname);
3948 : :
3949 : 3 : exit:
3950 : 3 : return return_value;
3951 : : }
3952 : :
3953 : : PyDoc_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 : :
3968 : : static PyObject *
3969 : : _curses_tigetstr_impl(PyObject *module, const char *capname);
3970 : :
3971 : : static PyObject *
3972 : 9 : _curses_tigetstr(PyObject *module, PyObject *arg)
3973 : : {
3974 : 9 : PyObject *return_value = NULL;
3975 : : const char *capname;
3976 : :
3977 [ - + ]: 9 : if (!PyUnicode_Check(arg)) {
3978 : 0 : _PyArg_BadArgument("tigetstr", "argument", "str", arg);
3979 : 0 : goto exit;
3980 : : }
3981 : : Py_ssize_t capname_length;
3982 : 9 : capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
3983 [ - + ]: 9 : if (capname == NULL) {
3984 : 0 : goto exit;
3985 : : }
3986 [ - + ]: 9 : if (strlen(capname) != (size_t)capname_length) {
3987 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
3988 : 0 : goto exit;
3989 : : }
3990 : 9 : return_value = _curses_tigetstr_impl(module, capname);
3991 : :
3992 : 9 : exit:
3993 : 9 : return return_value;
3994 : : }
3995 : :
3996 : : PyDoc_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_CAST(_curses_tparm), METH_FASTCALL, _curses_tparm__doc__},
4008 : :
4009 : : static 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 : :
4013 : : static PyObject *
4014 : 2 : _curses_tparm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
4015 : : {
4016 : 2 : PyObject *return_value = NULL;
4017 : : const char *str;
4018 : 2 : int i1 = 0;
4019 : 2 : int i2 = 0;
4020 : 2 : int i3 = 0;
4021 : 2 : int i4 = 0;
4022 : 2 : int i5 = 0;
4023 : 2 : int i6 = 0;
4024 : 2 : int i7 = 0;
4025 : 2 : int i8 = 0;
4026 : 2 : int i9 = 0;
4027 : :
4028 [ - + ]: 2 : if (!_PyArg_ParseStack(args, nargs, "y|iiiiiiiii:tparm",
4029 : : &str, &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9)) {
4030 : 0 : goto exit;
4031 : : }
4032 : 2 : return_value = _curses_tparm_impl(module, str, i1, i2, i3, i4, i5, i6, i7, i8, i9);
4033 : :
4034 : 2 : exit:
4035 : 2 : return return_value;
4036 : : }
4037 : :
4038 : : #if defined(HAVE_CURSES_TYPEAHEAD)
4039 : :
4040 : : PyDoc_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 : :
4054 : : static PyObject *
4055 : : _curses_typeahead_impl(PyObject *module, int fd);
4056 : :
4057 : : static PyObject *
4058 : 2 : _curses_typeahead(PyObject *module, PyObject *arg)
4059 : : {
4060 : 2 : PyObject *return_value = NULL;
4061 : : int fd;
4062 : :
4063 : 2 : fd = _PyLong_AsInt(arg);
4064 [ + + - + ]: 2 : if (fd == -1 && PyErr_Occurred()) {
4065 : 0 : goto exit;
4066 : : }
4067 : 2 : return_value = _curses_typeahead_impl(module, fd);
4068 : :
4069 : 2 : exit:
4070 : 2 : return return_value;
4071 : : }
4072 : :
4073 : : #endif /* defined(HAVE_CURSES_TYPEAHEAD) */
4074 : :
4075 : : PyDoc_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 : :
4087 : : PyDoc_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 : :
4098 : : PyDoc_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 : :
4111 : : PyDoc_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 : :
4129 : : static PyObject *
4130 : : _curses_use_env_impl(PyObject *module, int flag);
4131 : :
4132 : : static PyObject *
4133 : 2 : _curses_use_env(PyObject *module, PyObject *arg)
4134 : : {
4135 : 2 : PyObject *return_value = NULL;
4136 : : int flag;
4137 : :
4138 : 2 : flag = _PyLong_AsInt(arg);
4139 [ - + - - ]: 2 : if (flag == -1 && PyErr_Occurred()) {
4140 : 0 : goto exit;
4141 : : }
4142 : 2 : return_value = _curses_use_env_impl(module, flag);
4143 : :
4144 : 2 : exit:
4145 : 2 : return return_value;
4146 : : }
4147 : :
4148 : : #endif /* defined(HAVE_CURSES_USE_ENV) */
4149 : :
4150 : : #if !defined(STRICT_SYSV_CURSES)
4151 : :
4152 : : PyDoc_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 : :
4164 : : static PyObject *
4165 : : _curses_use_default_colors_impl(PyObject *module);
4166 : :
4167 : : static PyObject *
4168 : 2 : _curses_use_default_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
4169 : : {
4170 : 2 : return _curses_use_default_colors_impl(module);
4171 : : }
4172 : :
4173 : : #endif /* !defined(STRICT_SYSV_CURSES) */
4174 : :
4175 : : PyDoc_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 : :
4187 : : static PyObject *
4188 : : _curses_has_extended_color_support_impl(PyObject *module);
4189 : :
4190 : : static PyObject *
4191 : 5 : _curses_has_extended_color_support(PyObject *module, PyObject *Py_UNUSED(ignored))
4192 : : {
4193 : 5 : 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=1e2a8a160a0fe811 input=a9049054013a1b77]*/
|
