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