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