1 // * This makes emacs happy -*-Mode: C++;-*- 2 // vile:cppmode 3 /**************************************************************************** 4 * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. * 5 * * 6 * Permission is hereby granted, free of charge, to any person obtaining a * 7 * copy of this software and associated documentation files (the * 8 * "Software"), to deal in the Software without restriction, including * 9 * without limitation the rights to use, copy, modify, merge, publish, * 10 * distribute, distribute with modifications, sublicense, and/or sell * 11 * copies of the Software, and to permit persons to whom the Software is * 12 * furnished to do so, subject to the following conditions: * 13 * * 14 * The above copyright notice and this permission notice shall be included * 15 * in all copies or substantial portions of the Software. * 16 * * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 20 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 21 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 22 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 23 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 24 * * 25 * Except as contained in this notice, the name(s) of the above copyright * 26 * holders shall not be used in advertising or otherwise to promote the * 27 * sale, use or other dealings in this Software without prior written * 28 * authorization. * 29 ****************************************************************************/ 30 31 #ifndef NCURSES_CURSESW_H_incl 32 #define NCURSES_CURSESW_H_incl 1 33 34 // $Id: cursesw.h,v 1.48 2008/01/19 21:09:10 tom Exp $ 35 36 #include <etip.h> 37 38 extern "C" { 39 # include <curses.h> 40 } 41 42 /* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro. 43 Undefine it here, because NCursesWindow uses lines as a method. */ 44 #undef lines 45 46 /* "Convert" macros to inlines. We'll define it as another symbol to avoid 47 * conflict with library symbols. 48 */ 49 #undef UNDEF 50 #define UNDEF(name) CUR_ ##name 51 52 #ifdef addch 53 inline int UNDEF(addch)(chtype ch) { return addch(ch); } 54 #undef addch 55 #define addch UNDEF(addch) 56 #endif 57 58 #ifdef addchstr 59 inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); } 60 #undef addchstr 61 #define addchstr UNDEF(addchstr) 62 #endif 63 64 #ifdef addnstr 65 inline int UNDEF(addnstr)(const char *str, int n) 66 { return addnstr(str, n); } 67 #undef addnstr 68 #define addnstr UNDEF(addnstr) 69 #endif 70 71 #ifdef addstr 72 inline int UNDEF(addstr)(const char * str) { return addstr(str); } 73 #undef addstr 74 #define addstr UNDEF(addstr) 75 #endif 76 77 #ifdef attroff 78 inline int UNDEF(attroff)(chtype at) { return attroff(at); } 79 #undef attroff 80 #define attroff UNDEF(attroff) 81 #endif 82 83 #ifdef attron 84 inline int UNDEF(attron)(chtype at) { return attron(at); } 85 #undef attron 86 #define attron UNDEF(attron) 87 #endif 88 89 #ifdef attrset 90 inline chtype UNDEF(attrset)(chtype at) { return attrset(at); } 91 #undef attrset 92 #define attrset UNDEF(attrset) 93 #endif 94 95 #ifdef bkgd 96 inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); } 97 #undef bkgd 98 #define bkgd UNDEF(bkgd) 99 #endif 100 101 #ifdef bkgdset 102 inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); } 103 #undef bkgdset 104 #define bkgdset UNDEF(bkgdset) 105 #endif 106 107 #ifdef border 108 inline int UNDEF(border)(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br) 109 { return border(ls, rs, ts, bs, tl, tr, bl, br); } 110 #undef border 111 #define border UNDEF(border) 112 #endif 113 114 #ifdef box 115 inline int UNDEF(box)(WINDOW *win, int v, int h) { return box(win, v, h); } 116 #undef box 117 #define box UNDEF(box) 118 #endif 119 120 #ifdef chgat 121 inline int UNDEF(chgat)(int n, attr_t attr, short color, const void *opts) { 122 return chgat(n, attr, color, opts); } 123 #undef chgat 124 #define chgat UNDEF(chgat) 125 #endif 126 127 #ifdef clear 128 inline int UNDEF(clear)() { return clear(); } 129 #undef clear 130 #define clear UNDEF(clear) 131 #endif 132 133 #ifdef clearok 134 inline int UNDEF(clearok)(WINDOW* win, bool bf) { return clearok(win, bf); } 135 #undef clearok 136 #define clearok UNDEF(clearok) 137 #else 138 extern "C" NCURSES_IMPEXP int NCURSES_API clearok(WINDOW*, bool); 139 #endif 140 141 #ifdef clrtobot 142 inline int UNDEF(clrtobot)() { return clrtobot(); } 143 #undef clrtobot 144 #define clrtobot UNDEF(clrtobot) 145 #endif 146 147 #ifdef clrtoeol 148 inline int UNDEF(clrtoeol)() { return clrtoeol(); } 149 #undef clrtoeol 150 #define clrtoeol UNDEF(clrtoeol) 151 #endif 152 153 #ifdef color_set 154 inline chtype UNDEF(color_set)(short p, void* opts) { return color_set(p, opts); } 155 #undef color_set 156 #define color_set UNDEF(color_set) 157 #endif 158 159 #ifdef crmode 160 inline int UNDEF(crmode)(void) { return crmode(); } 161 #undef crmode 162 #define crmode UNDEF(crmode) 163 #endif 164 165 #ifdef delch 166 inline int UNDEF(delch)() { return delch(); } 167 #undef delch 168 #define delch UNDEF(delch) 169 #endif 170 171 #ifdef deleteln 172 inline int UNDEF(deleteln)() { return deleteln(); } 173 #undef deleteln 174 #define deleteln UNDEF(deleteln) 175 #endif 176 177 #ifdef echochar 178 inline int UNDEF(echochar)(chtype ch) { return echochar(ch); } 179 #undef echochar 180 #define echochar UNDEF(echochar) 181 #endif 182 183 #ifdef erase 184 inline int UNDEF(erase)() { return erase(); } 185 #undef erase 186 #define erase UNDEF(erase) 187 #endif 188 189 #ifdef fixterm 190 inline int UNDEF(fixterm)(void) { return fixterm(); } 191 #undef fixterm 192 #define fixterm UNDEF(fixterm) 193 #endif 194 195 #ifdef flushok 196 inline int UNDEF(flushok)(WINDOW* _win, bool _bf) { 197 return flushok(_win, _bf); } 198 #undef flushok 199 #define flushok UNDEF(flushok) 200 #else 201 #define _no_flushok 202 #endif 203 204 #ifdef getattrs 205 inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); } 206 #undef getattrs 207 #define getattrs UNDEF(getattrs) 208 #endif 209 210 #ifdef getbegyx 211 inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y, x); } 212 #undef getbegyx 213 #define getbegyx UNDEF(getbegyx) 214 #endif 215 216 #ifdef getbkgd 217 inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); } 218 #undef getbkgd 219 #define getbkgd UNDEF(getbkgd) 220 #endif 221 222 #ifdef getch 223 inline int UNDEF(getch)() { return getch(); } 224 #undef getch 225 #define getch UNDEF(getch) 226 #endif 227 228 #ifdef getmaxyx 229 inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y, x); } 230 #undef getmaxyx 231 #define getmaxyx UNDEF(getmaxyx) 232 #endif 233 234 #ifdef getnstr 235 inline int UNDEF(getnstr)(char *_str, int n) { return getnstr(_str, n); } 236 #undef getnstr 237 #define getnstr UNDEF(getnstr) 238 #endif 239 240 #ifdef getparyx 241 inline void UNDEF(getparyx)(WINDOW* win, int& y, int& x) { getparyx(win, y, x); } 242 #undef getparyx 243 #define getparyx UNDEF(getparyx) 244 #endif 245 246 #ifdef getstr 247 inline int UNDEF(getstr)(char *_str) { return getstr(_str); } 248 #undef getstr 249 #define getstr UNDEF(getstr) 250 #endif 251 252 #ifdef getyx 253 inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) { 254 getyx(win, y, x); } 255 #undef getyx 256 #define getyx UNDEF(getyx) 257 #endif 258 259 #ifdef hline 260 inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); } 261 #undef hline 262 #define hline UNDEF(hline) 263 #endif 264 265 #ifdef inch 266 inline chtype UNDEF(inch)() { return inch(); } 267 #undef inch 268 #define inch UNDEF(inch) 269 #endif 270 271 #ifdef inchstr 272 inline int UNDEF(inchstr)(chtype *str) { return inchstr(str); } 273 #undef inchstr 274 #define inchstr UNDEF(inchstr) 275 #endif 276 277 #ifdef innstr 278 inline int UNDEF(innstr)(char *_str, int n) { return innstr(_str, n); } 279 #undef innstr 280 #define innstr UNDEF(innstr) 281 #endif 282 283 #ifdef insch 284 inline int UNDEF(insch)(chtype c) { return insch(c); } 285 #undef insch 286 #define insch UNDEF(insch) 287 #endif 288 289 #ifdef insdelln 290 inline int UNDEF(insdelln)(int n) { return insdelln(n); } 291 #undef insdelln 292 #define insdelln UNDEF(insdelln) 293 #endif 294 295 #ifdef insertln 296 inline int UNDEF(insertln)() { return insertln(); } 297 #undef insertln 298 #define insertln UNDEF(insertln) 299 #endif 300 301 #ifdef insnstr 302 inline int UNDEF(insnstr)(const char *_str, int n) { 303 return insnstr(_str, n); } 304 #undef insnstr 305 #define insnstr UNDEF(insnstr) 306 #endif 307 308 #ifdef insstr 309 inline int UNDEF(insstr)(const char *_str) { 310 return insstr(_str); } 311 #undef insstr 312 #define insstr UNDEF(insstr) 313 #endif 314 315 #ifdef instr 316 inline int UNDEF(instr)(char *_str) { return instr(_str); } 317 #undef instr 318 #define instr UNDEF(instr) 319 #endif 320 321 #ifdef intrflush 322 inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); } 323 #undef intrflush 324 #define intrflush UNDEF(intrflush) 325 #endif 326 327 #ifdef leaveok 328 inline int UNDEF(leaveok)(WINDOW* win, bool bf) { return leaveok(win, bf); } 329 #undef leaveok 330 #define leaveok UNDEF(leaveok) 331 #else 332 extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf); 333 #endif 334 335 #ifdef move 336 inline int UNDEF(move)(int x, int y) { return move(x, y); } 337 #undef move 338 #define move UNDEF(move) 339 #endif 340 341 #ifdef mvaddch 342 inline int UNDEF(mvaddch)(int y, int x, chtype ch) 343 { return mvaddch(y, x, ch); } 344 #undef mvaddch 345 #define mvaddch UNDEF(mvaddch) 346 #endif 347 348 #ifdef mvaddnstr 349 inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n) 350 { return mvaddnstr(y, x, str, n); } 351 #undef mvaddnstr 352 #define mvaddnstr UNDEF(mvaddnstr) 353 #endif 354 355 #ifdef mvaddstr 356 inline int UNDEF(mvaddstr)(int y, int x, const char * str) 357 { return mvaddstr(y, x, str); } 358 #undef mvaddstr 359 #define mvaddstr UNDEF(mvaddstr) 360 #endif 361 362 #ifdef mvchgat 363 inline int UNDEF(mvchgat)(int y, int x, int n, 364 attr_t attr, short color, const void *opts) { 365 return mvchgat(y, x, n, attr, color, opts); } 366 #undef mvchgat 367 #define mvchgat UNDEF(mvchgat) 368 #endif 369 370 #ifdef mvdelch 371 inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);} 372 #undef mvdelch 373 #define mvdelch UNDEF(mvdelch) 374 #endif 375 376 #ifdef mvgetch 377 inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);} 378 #undef mvgetch 379 #define mvgetch UNDEF(mvgetch) 380 #endif 381 382 #ifdef mvgetnstr 383 inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) { 384 return mvgetnstr(y, x, str, n);} 385 #undef mvgetnstr 386 #define mvgetnstr UNDEF(mvgetnstr) 387 #endif 388 389 #ifdef mvgetstr 390 inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);} 391 #undef mvgetstr 392 #define mvgetstr UNDEF(mvgetstr) 393 #endif 394 395 #ifdef mvinch 396 inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);} 397 #undef mvinch 398 #define mvinch UNDEF(mvinch) 399 #endif 400 401 #ifdef mvinnstr 402 inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) { 403 return mvinnstr(y, x, _str, n); } 404 #undef mvinnstr 405 #define mvinnstr UNDEF(mvinnstr) 406 #endif 407 408 #ifdef mvinsch 409 inline int UNDEF(mvinsch)(int y, int x, chtype c) 410 { return mvinsch(y, x, c); } 411 #undef mvinsch 412 #define mvinsch UNDEF(mvinsch) 413 #endif 414 415 #ifdef mvinsnstr 416 inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) { 417 return mvinsnstr(y, x, _str, n); } 418 #undef mvinsnstr 419 #define mvinsnstr UNDEF(mvinsnstr) 420 #endif 421 422 #ifdef mvinsstr 423 inline int UNDEF(mvinsstr)(int y, int x, const char *_str) { 424 return mvinsstr(y, x, _str); } 425 #undef mvinsstr 426 #define mvinsstr UNDEF(mvinsstr) 427 #endif 428 429 #ifdef mvwaddch 430 inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch) 431 { return mvwaddch(win, y, x, ch); } 432 #undef mvwaddch 433 #define mvwaddch UNDEF(mvwaddch) 434 #endif 435 436 #ifdef mvwaddchnstr 437 inline int UNDEF(mvwaddchnstr)(WINDOW *win, int y, int x, const chtype *str, int n) 438 { return mvwaddchnstr(win, y, x, str, n); } 439 #undef mvwaddchnstr 440 #define mvwaddchnstr UNDEF(mvwaddchnstr) 441 #endif 442 443 #ifdef mvwaddchstr 444 inline int UNDEF(mvwaddchstr)(WINDOW *win, int y, int x, const chtype *str) 445 { return mvwaddchstr(win, y, x, str); } 446 #undef mvwaddchstr 447 #define mvwaddchstr UNDEF(mvwaddchstr) 448 #endif 449 450 #ifdef mvwaddnstr 451 inline int UNDEF(mvwaddnstr)(WINDOW *win, int y, int x, const char *str, int n) 452 { return mvwaddnstr(win, y, x, str, n); } 453 #undef mvwaddnstr 454 #define mvwaddnstr UNDEF(mvwaddnstr) 455 #endif 456 457 #ifdef mvwaddstr 458 inline int UNDEF(mvwaddstr)(WINDOW *win, int y, int x, const char * str) 459 { return mvwaddstr(win, y, x, str); } 460 #undef mvwaddstr 461 #define mvwaddstr UNDEF(mvwaddstr) 462 #endif 463 464 #ifdef mvwchgat 465 inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n, 466 attr_t attr, short color, const void *opts) { 467 return mvwchgat(win, y, x, n, attr, color, opts); } 468 #undef mvwchgat 469 #define mvwchgat UNDEF(mvwchgat) 470 #endif 471 472 #ifdef mvwdelch 473 inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x) 474 { return mvwdelch(win, y, x); } 475 #undef mvwdelch 476 #define mvwdelch UNDEF(mvwdelch) 477 #endif 478 479 #ifdef mvwgetch 480 inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);} 481 #undef mvwgetch 482 #define mvwgetch UNDEF(mvwgetch) 483 #endif 484 485 #ifdef mvwgetnstr 486 inline int UNDEF(mvwgetnstr)(WINDOW *win, int y, int x, char *str, int n) 487 {return mvwgetnstr(win, y, x, str, n);} 488 #undef mvwgetnstr 489 #define mvwgetnstr UNDEF(mvwgetnstr) 490 #endif 491 492 #ifdef mvwgetstr 493 inline int UNDEF(mvwgetstr)(WINDOW *win, int y, int x, char *str) 494 {return mvwgetstr(win, y, x, str);} 495 #undef mvwgetstr 496 #define mvwgetstr UNDEF(mvwgetstr) 497 #endif 498 499 #ifdef mvwhline 500 inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) { 501 return mvwhline(win, y, x, c, n); } 502 #undef mvwhline 503 #define mvwhline UNDEF(mvwhline) 504 #endif 505 506 #ifdef mvwinch 507 inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) { 508 return mvwinch(win, y, x);} 509 #undef mvwinch 510 #define mvwinch UNDEF(mvwinch) 511 #endif 512 513 #ifdef mvwinchnstr 514 inline int UNDEF(mvwinchnstr)(WINDOW *win, int y, int x, chtype *str, int n) { return mvwinchnstr(win, y, x, str, n); } 515 #undef mvwinchnstr 516 #define mvwinchnstr UNDEF(mvwinchnstr) 517 #endif 518 519 #ifdef mvwinchstr 520 inline int UNDEF(mvwinchstr)(WINDOW *win, int y, int x, chtype *str) { return mvwinchstr(win, y, x, str); } 521 #undef mvwinchstr 522 #define mvwinchstr UNDEF(mvwinchstr) 523 #endif 524 525 #ifdef mvwinnstr 526 inline int UNDEF(mvwinnstr)(WINDOW *win, int y, int x, char *_str, int n) { 527 return mvwinnstr(win, y, x, _str, n); } 528 #undef mvwinnstr 529 #define mvwinnstr UNDEF(mvwinnstr) 530 #endif 531 532 #ifdef mvwinsch 533 inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c) 534 { return mvwinsch(win, y, x, c); } 535 #undef mvwinsch 536 #define mvwinsch UNDEF(mvwinsch) 537 #endif 538 539 #ifdef mvwinsnstr 540 inline int UNDEF(mvwinsnstr)(WINDOW *w, int y, int x, const char *_str, int n) { 541 return mvwinsnstr(w, y, x, _str, n); } 542 #undef mvwinsnstr 543 #define mvwinsnstr UNDEF(mvwinsnstr) 544 #endif 545 546 #ifdef mvwinsstr 547 inline int UNDEF(mvwinsstr)(WINDOW *w, int y, int x, const char *_str) { 548 return mvwinsstr(w, y, x, _str); } 549 #undef mvwinsstr 550 #define mvwinsstr UNDEF(mvwinsstr) 551 #endif 552 553 #ifdef mvwvline 554 inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) { 555 return mvwvline(win, y, x, c, n); } 556 #undef mvwvline 557 #define mvwvline UNDEF(mvwvline) 558 #endif 559 560 #ifdef napms 561 inline void UNDEF(napms)(unsigned long x) { napms(x); } 562 #undef napms 563 #define napms UNDEF(napms) 564 #endif 565 566 #ifdef nocrmode 567 inline int UNDEF(nocrmode)(void) { return nocrmode(); } 568 #undef nocrmode 569 #define nocrmode UNDEF(nocrmode) 570 #endif 571 572 #ifdef nodelay 573 inline void UNDEF(nodelay)() { nodelay(); } 574 #undef nodelay 575 #define nodelay UNDEF(nodelay) 576 #endif 577 578 #ifdef redrawwin 579 inline int UNDEF(redrawwin)(WINDOW *win) { return redrawwin(win); } 580 #undef redrawwin 581 #define redrawwin UNDEF(redrawwin) 582 #endif 583 584 #ifdef refresh 585 inline int UNDEF(refresh)() { return refresh(); } 586 #undef refresh 587 #define refresh UNDEF(refresh) 588 #endif 589 590 #ifdef resetterm 591 inline int UNDEF(resetterm)(void) { return resetterm(); } 592 #undef resetterm 593 #define resetterm UNDEF(resetterm) 594 #endif 595 596 #ifdef saveterm 597 inline int UNDEF(saveterm)(void) { return saveterm(); } 598 #undef saveterm 599 #define saveterm UNDEF(saveterm) 600 #endif 601 602 #ifdef scrl 603 inline int UNDEF(scrl)(int l) { return scrl(l); } 604 #undef scrl 605 #define scrl UNDEF(scrl) 606 #endif 607 608 #ifdef scroll 609 inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); } 610 #undef scroll 611 #define scroll UNDEF(scroll) 612 #endif 613 614 #ifdef scrollok 615 inline int UNDEF(scrollok)(WINDOW* win, bool bf) { return scrollok(win, bf); } 616 #undef scrollok 617 #define scrollok UNDEF(scrollok) 618 #else 619 #if defined(__NCURSES_H) 620 extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool); 621 #else 622 extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char); 623 #endif 624 #endif 625 626 #ifdef setscrreg 627 inline int UNDEF(setscrreg)(int t, int b) { return setscrreg(t, b); } 628 #undef setscrreg 629 #define setscrreg UNDEF(setscrreg) 630 #endif 631 632 #ifdef standend 633 inline int UNDEF(standend)() { return standend(); } 634 #undef standend 635 #define standend UNDEF(standend) 636 #endif 637 638 #ifdef standout 639 inline int UNDEF(standout)() { return standout(); } 640 #undef standout 641 #define standout UNDEF(standout) 642 #endif 643 644 #ifdef subpad 645 inline WINDOW *UNDEF(subpad)(WINDOW *p, int l, int c, int y, int x) 646 { return derwin(p, l, c, y, x); } 647 #undef subpad 648 #define subpad UNDEF(subpad) 649 #endif 650 651 #ifdef timeout 652 inline void UNDEF(timeout)(int delay) { timeout(delay); } 653 #undef timeout 654 #define timeout UNDEF(timeout) 655 #endif 656 657 #ifdef touchline 658 inline int UNDEF(touchline)(WINDOW *win, int s, int c) 659 { return touchline(win, s, c); } 660 #undef touchline 661 #define touchline UNDEF(touchline) 662 #endif 663 664 #ifdef touchwin 665 inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); } 666 #undef touchwin 667 #define touchwin UNDEF(touchwin) 668 #endif 669 670 #ifdef untouchwin 671 inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); } 672 #undef untouchwin 673 #define untouchwin UNDEF(untouchwin) 674 #endif 675 676 #ifdef vline 677 inline int UNDEF(vline)(chtype ch, int n) { return vline(ch, n); } 678 #undef vline 679 #define vline UNDEF(vline) 680 #endif 681 682 #ifdef waddchstr 683 inline int UNDEF(waddchstr)(WINDOW *win, chtype *at) { return waddchstr(win, at); } 684 #undef waddchstr 685 #define waddchstr UNDEF(waddchstr) 686 #endif 687 688 #ifdef waddstr 689 inline int UNDEF(waddstr)(WINDOW *win, char *str) { return waddstr(win, str); } 690 #undef waddstr 691 #define waddstr UNDEF(waddstr) 692 #endif 693 694 #ifdef wattroff 695 inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att); } 696 #undef wattroff 697 #define wattroff UNDEF(wattroff) 698 #endif 699 700 #ifdef wattrset 701 inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att); } 702 #undef wattrset 703 #define wattrset UNDEF(wattrset) 704 #endif 705 706 #ifdef winch 707 inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); } 708 #undef winch 709 #define winch UNDEF(winch) 710 #endif 711 712 #ifdef winchnstr 713 inline int UNDEF(winchnstr)(WINDOW *win, chtype *str, int n) { return winchnstr(win, str, n); } 714 #undef winchnstr 715 #define winchnstr UNDEF(winchnstr) 716 #endif 717 718 #ifdef winchstr 719 inline int UNDEF(winchstr)(WINDOW *win, chtype *str) { return winchstr(win, str); } 720 #undef winchstr 721 #define winchstr UNDEF(winchstr) 722 #endif 723 724 #ifdef winsstr 725 inline int UNDEF(winsstr)(WINDOW *w, const char *_str) { 726 return winsstr(w, _str); } 727 #undef winsstr 728 #define winsstr UNDEF(winsstr) 729 #endif 730 731 #ifdef wstandend 732 inline int UNDEF(wstandend)(WINDOW *win) { return wstandend(win); } 733 #undef wstandend 734 #define wstandend UNDEF(wstandend) 735 #endif 736 737 #ifdef wstandout 738 inline int UNDEF(wstandout)(WINDOW *win) { return wstandout(win); } 739 #undef wstandout 740 #define wstandout UNDEF(wstandout) 741 #endif 742 743 /* 744 * 745 * C++ class for windows. 746 * 747 */ 748 749 extern "C" int _nc_ripoffline(int, int (*init)(WINDOW*, int)); 750 extern "C" int _nc_xx_ripoff_init(WINDOW *, int); 751 extern "C" int _nc_has_mouse(void); 752 753 class NCURSES_IMPEXP NCursesWindow 754 { 755 friend class NCursesMenu; 756 friend class NCursesForm; 757 758 private: 759 static bool b_initialized; 760 static void initialize(); 761 void constructing(); 762 friend int _nc_xx_ripoff_init(WINDOW *, int); 763 764 void set_keyboard(); 765 766 short getcolor(int getback) const; 767 short getPair() const; 768 769 static int setpalette(short fore, short back, short pair); 770 static int colorInitialized; 771 772 // This private constructor is only used during the initialization 773 // of windows generated by ripoffline() calls. 774 NCursesWindow(WINDOW* win, int ncols); 775 776 protected: 777 virtual void err_handler(const char *) const THROWS(NCursesException); 778 // Signal an error with the given message text. 779 780 static long count; // count of all active windows: 781 // We rely on the c++ promise that 782 // all otherwise uninitialized 783 // static class vars are set to 0 784 785 WINDOW* w; // the curses WINDOW 786 787 bool alloced; // TRUE if we own the WINDOW 788 789 NCursesWindow* par; // parent, if subwindow 790 NCursesWindow* subwins; // head of subwindows list 791 NCursesWindow* sib; // next subwindow of parent 792 793 void kill_subwindows(); // disable all subwindows 794 // Destroy all subwindows. 795 796 /* Only for use by derived classes. They are then in charge to 797 fill the member variables correctly. */ 798 NCursesWindow(); 799 800 public: 801 NCursesWindow(WINDOW* window); // useful only for stdscr 802 803 NCursesWindow(int nlines, // number of lines 804 int ncols, // number of columns 805 int begin_y, // line origin 806 int begin_x); // col origin 807 808 NCursesWindow(NCursesWindow& par,// parent window 809 int nlines, // number of lines 810 int ncols, // number of columns 811 int begin_y, // absolute or relative 812 int begin_x, // origins: 813 char absrel = 'a');// if `a', begin_y & begin_x are 814 // absolute screen pos, else if `r', they are relative to par origin 815 816 NCursesWindow(NCursesWindow& par,// parent window 817 bool do_box = TRUE); 818 // this is the very common case that we want to create the subwindow that 819 // is two lines and two columns smaller and begins at (1,1). 820 // We may automatically request the box around it. 821 822 NCursesWindow& operator=(const NCursesWindow& rhs) 823 { 824 if (this != &rhs) 825 *this = rhs; 826 return *this; 827 } 828 829 NCursesWindow(const NCursesWindow& rhs) 830 : w(rhs.w), alloced(rhs.alloced), par(rhs.par), subwins(rhs.subwins), sib(rhs.sib) 831 { 832 } 833 834 virtual ~NCursesWindow(); 835 836 NCursesWindow Clone(); 837 // Make an exact copy of the window. 838 839 // Initialization. 840 static void useColors(void); 841 // Call this routine very early if you want to have colors. 842 843 static int ripoffline(int ripoff_lines, 844 int (*init)(NCursesWindow& win)); 845 // This function is used to generate a window of ripped-of lines. 846 // If the argument is positive, lines are removed from the top, if it 847 // is negative lines are removed from the bottom. This enhances the 848 // lowlevel ripoffline() function because it uses the internal 849 // implementation that allows to remove more than just a single line. 850 // This function must be called before any other ncurses function. The 851 // creation of the window is deferred until ncurses gets initialized. 852 // The initialization function is then called. 853 854 // ------------------------------------------------------------------------- 855 // terminal status 856 // ------------------------------------------------------------------------- 857 int lines() const { initialize(); return LINES; } 858 // Number of lines on terminal, *not* window 859 860 int cols() const { initialize(); return COLS; } 861 // Number of cols on terminal, *not* window 862 863 int tabsize() const { initialize(); return TABSIZE; } 864 // Size of a tab on terminal, *not* window 865 866 static int NumberOfColors(); 867 // Number of available colors 868 869 int colors() const { return NumberOfColors(); } 870 // Number of available colors 871 872 // ------------------------------------------------------------------------- 873 // window status 874 // ------------------------------------------------------------------------- 875 int height() const { return maxy() + 1; } 876 // Number of lines in this window 877 878 int width() const { return maxx() + 1; } 879 // Number of columns in this window 880 881 int begx() const { return getbegx(w); } 882 // Column of top left corner relative to stdscr 883 884 int begy() const { return getbegy(w); } 885 // Line of top left corner relative to stdscr 886 887 int curx() const { return getcurx(w); } 888 // Column of top left corner relative to stdscr 889 890 int cury() const { return getcury(w); } 891 // Line of top left corner relative to stdscr 892 893 int maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)-1; } 894 // Largest x coord in window 895 896 int maxy() const { return getmaxy(w) == ERR ? ERR : getmaxy(w)-1; } 897 // Largest y coord in window 898 899 short getcolor() const; 900 // Actual color pair 901 902 short foreground() const { return getcolor(0); } 903 // Actual foreground color 904 905 short background() const { return getcolor(1); } 906 // Actual background color 907 908 int setpalette(short fore, short back); 909 // Set color palette entry 910 911 int setcolor(short pair); 912 // Set actually used palette entry 913 914 // ------------------------------------------------------------------------- 915 // window positioning 916 // ------------------------------------------------------------------------- 917 virtual int mvwin(int begin_y, int begin_x) { 918 return ::mvwin(w, begin_y, begin_x); } 919 // Move window to new position with the new position as top left corner. 920 // This is virtual because it is redefined in NCursesPanel. 921 922 // ------------------------------------------------------------------------- 923 // coordinate positioning 924 // ------------------------------------------------------------------------- 925 int move(int y, int x) { return ::wmove(w, y, x); } 926 // Move cursor the this position 927 928 void getyx(int& y, int& x) const { ::getyx(w, y, x); } 929 // Get current position of the cursor 930 931 void getbegyx(int& y, int& x) const { ::getbegyx(w, y, x); } 932 // Get beginning of the window 933 934 void getmaxyx(int& y, int& x) const { ::getmaxyx(w, y, x); } 935 // Get size of the window 936 937 void getparyx(int& y, int& x) const { ::getparyx(w, y, x); } 938 // Get parent's beginning of the window 939 940 int mvcur(int oldrow, int oldcol, int newrow, int newcol) const { 941 return ::mvcur(oldrow, oldcol, newrow, newcol); } 942 // Perform lowlevel cursor motion that takes effect immediately. 943 944 // ------------------------------------------------------------------------- 945 // input 946 // ------------------------------------------------------------------------- 947 int getch() { return ::wgetch(w); } 948 // Get a keystroke from the window. 949 950 int getch(int y, int x) { return ::mvwgetch(w, y, x); } 951 // Move cursor to position and get a keystroke from the window 952 953 int getstr(char* str, int n=-1) { 954 return ::wgetnstr(w, str, n); } 955 // Read a series of characters into str until a newline or carriage return 956 // is received. Read at most n characters. If n is negative, the limit is 957 // ignored. 958 959 int getstr(int y, int x, char* str, int n=-1) { 960 return ::mvwgetnstr(w, y, x, str, n); } 961 // Move the cursor to the requested position and then perform the getstr() 962 // as described above. 963 964 int instr(char *s, int n=-1) { return ::winnstr(w, s, n); } 965 // Get a string of characters from the window into the buffer s. Retrieve 966 // at most n characters, if n is negative retrieve all characters up to the 967 // end of the current line. Attributes are stripped from the characters. 968 969 int instr(int y, int x, char *s, int n=-1) { 970 return ::mvwinnstr(w, y, x, s, n); } 971 // Move the cursor to the requested position and then perform the instr() 972 // as described above. 973 974 int scanw(const char* fmt, ...) 975 // Perform a scanw function from the window. 976 #if __GNUG__ >= 2 977 __attribute__ ((format (scanf, 2, 3))); 978 #else 979 ; 980 #endif 981 982 int scanw(const char*, va_list); 983 // Perform a scanw function from the window. 984 985 int scanw(int y, int x, const char* fmt, ...) 986 // Move the cursor to the requested position and then perform a scanw 987 // from the window. 988 #if __GNUG__ >= 2 989 __attribute__ ((format (scanf, 4, 5))); 990 #else 991 ; 992 #endif 993 994 int scanw(int y, int x, const char* fmt, va_list); 995 // Move the cursor to the requested position and then perform a scanw 996 // from the window. 997 998 // ------------------------------------------------------------------------- 999 // output 1000 // ------------------------------------------------------------------------- 1001 int addch(const chtype ch) { return ::waddch(w, ch); } 1002 // Put attributed character to the window. 1003 1004 int addch(int y, int x, const chtype ch) { 1005 return ::mvwaddch(w, y, x, ch); } 1006 // Move cursor to the requested position and then put attributed character 1007 // to the window. 1008 1009 int echochar(const chtype ch) { return ::wechochar(w, ch); } 1010 // Put attributed character to the window and refresh it immediately. 1011 1012 int addstr(const char* str, int n=-1) { 1013 return ::waddnstr(w, str, n); } 1014 // Write the string str to the window, stop writing if the terminating 1015 // NUL or the limit n is reached. If n is negative, it is ignored. 1016 1017 int addstr(int y, int x, const char * str, int n=-1) { 1018 return ::mvwaddnstr(w, y, x, str, n); } 1019 // Move the cursor to the requested position and then perform the addchstr 1020 // as described above. 1021 1022 int addchstr(const chtype* str, int n=-1) { 1023 return ::waddchnstr(w, str, n); } 1024 // Write the string str to the window, stop writing if the terminating 1025 // NUL or the limit n is reached. If n is negative, it is ignored. 1026 1027 int addchstr(int y, int x, const chtype * str, int n=-1) { 1028 return ::mvwaddchnstr(w, y, x, str, n); } 1029 // Move the cursor to the requested position and then perform the addchstr 1030 // as described above. 1031 1032 int printw(const char* fmt, ...) 1033 // Do a formatted print to the window. 1034 #if (__GNUG__ >= 2) && !defined(printf) 1035 __attribute__ ((format (printf, 2, 3))); 1036 #else 1037 ; 1038 #endif 1039 1040 int printw(int y, int x, const char * fmt, ...) 1041 // Move the cursor and then do a formatted print to the window. 1042 #if (__GNUG__ >= 2) && !defined(printf) 1043 __attribute__ ((format (printf, 4, 5))); 1044 #else 1045 ; 1046 #endif 1047 1048 int printw(const char* fmt, va_list args); 1049 // Do a formatted print to the window. 1050 1051 int printw(int y, int x, const char * fmt, va_list args); 1052 // Move the cursor and then do a formatted print to the window. 1053 1054 chtype inch() const { return ::winch(w); } 1055 // Retrieve attributed character under the current cursor position. 1056 1057 chtype inch(int y, int x) { return ::mvwinch(w, y, x); } 1058 // Move cursor to requested position and then retrieve attributed character 1059 // at this position. 1060 1061 int inchstr(chtype* str, int n=-1) { 1062 return ::winchnstr(w, str, n); } 1063 // Read the string str from the window, stop reading if the terminating 1064 // NUL or the limit n is reached. If n is negative, it is ignored. 1065 1066 int inchstr(int y, int x, chtype * str, int n=-1) { 1067 return ::mvwinchnstr(w, y, x, str, n); } 1068 // Move the cursor to the requested position and then perform the inchstr 1069 // as described above. 1070 1071 int insch(chtype ch) { return ::winsch(w, ch); } 1072 // Insert attributed character into the window before current cursor 1073 // position. 1074 1075 int insch(int y, int x, chtype ch) { 1076 return ::mvwinsch(w, y, x, ch); } 1077 // Move cursor to requested position and then insert the attributed 1078 // character before that position. 1079 1080 int insertln() { return ::winsdelln(w, 1); } 1081 // Insert an empty line above the current line. 1082 1083 int insdelln(int n=1) { return ::winsdelln(w, n); } 1084 // If n>0 insert that many lines above the current line. If n<0 delete 1085 // that many lines beginning with the current line. 1086 1087 int insstr(const char *s, int n=-1) { 1088 return ::winsnstr(w, s, n); } 1089 // Insert the string into the window before the current cursor position. 1090 // Insert stops at end of string or when the limit n is reached. If n is 1091 // negative, it is ignored. 1092 1093 int insstr(int y, int x, const char *s, int n=-1) { 1094 return ::mvwinsnstr(w, y, x, s, n); } 1095 // Move the cursor to the requested position and then perform the insstr() 1096 // as described above. 1097 1098 int attron (chtype at) { return ::wattron (w, at); } 1099 // Switch on the window attributes; 1100 1101 int attroff(chtype at) { return ::wattroff(w, static_cast<int>(at)); } 1102 // Switch off the window attributes; 1103 1104 int attrset(chtype at) { return ::wattrset(w, static_cast<int>(at)); } 1105 // Set the window attributes; 1106 1107 chtype attrget() { return ::getattrs(w); } 1108 // Get the window attributes; 1109 1110 int color_set(short color_pair_number, void* opts=NULL) { 1111 return ::wcolor_set(w, color_pair_number, opts); } 1112 // Set the window color attribute; 1113 1114 int chgat(int n, attr_t attr, short color, const void *opts=NULL) { 1115 return ::wchgat(w, n, attr, color, opts); } 1116 // Change the attributes of the next n characters in the current line. If 1117 // n is negative or greater than the number of remaining characters in the 1118 // line, the attributes will be changed up to the end of the line. 1119 1120 int chgat(int y, int x, 1121 int n, attr_t attr, short color, const void *opts=NULL) { 1122 return ::mvwchgat(w, y, x, n, attr, color, opts); } 1123 // Move the cursor to the requested position and then perform chgat() as 1124 // described above. 1125 1126 // ------------------------------------------------------------------------- 1127 // background 1128 // ------------------------------------------------------------------------- 1129 chtype getbkgd() const { return ::getbkgd(w); } 1130 // Get current background setting. 1131 1132 int bkgd(const chtype ch) { return ::wbkgd(w, ch); } 1133 // Set the background property and apply it to the window. 1134 1135 void bkgdset(chtype ch) { ::wbkgdset(w, ch); } 1136 // Set the background property. 1137 1138 // ------------------------------------------------------------------------- 1139 // borders 1140 // ------------------------------------------------------------------------- 1141 int box(chtype vert=0, chtype hor=0) { 1142 return ::wborder(w, vert, vert, hor, hor, 0, 0, 0, 0); } 1143 // Draw a box around the window with the given vertical and horizontal 1144 // drawing characters. If you specify a zero as character, curses will try 1145 // to find a "nice" character. 1146 1147 int border(chtype left=0, chtype right=0, 1148 chtype top =0, chtype bottom=0, 1149 chtype top_left =0, chtype top_right=0, 1150 chtype bottom_left =0, chtype bottom_right=0) { 1151 return ::wborder(w, left, right, top, bottom, top_left, top_right, 1152 bottom_left, bottom_right); } 1153 // Draw a border around the window with the given characters for the 1154 // various parts of the border. If you pass zero for a character, curses 1155 // will try to find "nice" characters. 1156 1157 // ------------------------------------------------------------------------- 1158 // lines and boxes 1159 // ------------------------------------------------------------------------- 1160 int hline(int len, chtype ch=0) { return ::whline(w, ch, len); } 1161 // Draw a horizontal line of len characters with the given character. If 1162 // you pass zero for the character, curses will try to find a "nice" one. 1163 1164 int hline(int y, int x, int len, chtype ch=0) { 1165 return ::mvwhline(w, y, x, ch, len); } 1166 // Move the cursor to the requested position and then draw a horizontal line. 1167 1168 int vline(int len, chtype ch=0) { return ::wvline(w, ch, len); } 1169 // Draw a vertical line of len characters with the given character. If 1170 // you pass zero for the character, curses will try to find a "nice" one. 1171 1172 int vline(int y, int x, int len, chtype ch=0) { 1173 return ::mvwvline(w, y, x, ch, len); } 1174 // Move the cursor to the requested position and then draw a vertical line. 1175 1176 // ------------------------------------------------------------------------- 1177 // erasure 1178 // ------------------------------------------------------------------------- 1179 int erase() { return ::werase(w); } 1180 // Erase the window. 1181 1182 int clear() { return ::wclear(w); } 1183 // Clear the window. 1184 1185 int clearok(bool bf) { return ::clearok(w, bf); } 1186 // Set/Reset the clear flag. If set, the next refresh() will clear the 1187 // screen. 1188 1189 int clrtobot() { return ::wclrtobot(w); } 1190 // Clear to the end of the window. 1191 1192 int clrtoeol() { return ::wclrtoeol(w); } 1193 // Clear to the end of the line. 1194 1195 int delch() { return ::wdelch(w); } 1196 // Delete character under the cursor. 1197 1198 int delch(int y, int x) { return ::mvwdelch(w, y, x); } 1199 // Move cursor to requested position and delete the character under the 1200 // cursor. 1201 1202 int deleteln() { return ::winsdelln(w, -1); } 1203 // Delete the current line. 1204 1205 // ------------------------------------------------------------------------- 1206 // screen control 1207 // ------------------------------------------------------------------------- 1208 int scroll(int amount=1) { return ::wscrl(w, amount); } 1209 // Scroll amount lines. If amount is positive, scroll up, otherwise 1210 // scroll down. 1211 1212 int scrollok(bool bf) { return ::scrollok(w, bf); } 1213 // If bf is TRUE, window scrolls if cursor is moved off the bottom 1214 // edge of the window or a scrolling region, otherwise the cursor is left 1215 // at the bottom line. 1216 1217 int setscrreg(int from, int to) { 1218 return ::wsetscrreg(w, from, to); } 1219 // Define a soft scrolling region. 1220 1221 int idlok(bool bf) { return ::idlok(w, bf); } 1222 // If bf is TRUE, use insert/delete line hardware support if possible. 1223 // Otherwise do it in software. 1224 1225 void idcok(bool bf) { ::idcok(w, bf); } 1226 // If bf is TRUE, use insert/delete character hardware support if possible. 1227 // Otherwise do it in software. 1228 1229 int touchline(int s, int c) { return ::touchline(w, s, c); } 1230 // Mark the given lines as modified. 1231 1232 int touchwin() { return ::wtouchln(w, 0, height(), 1); } 1233 // Mark the whole window as modified. 1234 1235 int untouchwin() { return ::wtouchln(w, 0, height(), 0); } 1236 // Mark the whole window as unmodified. 1237 1238 int touchln(int s, int cnt, bool changed=TRUE) { 1239 return ::wtouchln(w, s, cnt, static_cast<int>(changed ? 1 : 0)); } 1240 // Mark cnt lines beginning from line s as changed or unchanged, depending 1241 // on the value of the changed flag. 1242 1243 bool is_linetouched(int line) const { 1244 return (::is_linetouched(w, line) ? TRUE:FALSE); } 1245 // Return TRUE if line is marked as changed, FALSE otherwise 1246 1247 bool is_wintouched() const { 1248 return (::is_wintouched(w) ? TRUE:FALSE); } 1249 // Return TRUE if window is marked as changed, FALSE otherwise 1250 1251 int leaveok(bool bf) { return ::leaveok(w, bf); } 1252 // If bf is TRUE, curses will leave the cursor after an update whereever 1253 // it is after the update. 1254 1255 int redrawln(int from, int n) { return ::wredrawln(w, from, n); } 1256 // Redraw n lines starting from the requested line 1257 1258 int redrawwin() { return ::wredrawln(w, 0, height()); } 1259 // Redraw the whole window 1260 1261 int doupdate() { return ::doupdate(); } 1262 // Do all outputs to make the physical screen looking like the virtual one 1263 1264 void syncdown() { ::wsyncdown(w); } 1265 // Propagate the changes down to all descendant windows 1266 1267 void syncup() { ::wsyncup(w); } 1268 // Propagate the changes up in the hierarchy 1269 1270 void cursyncup() { ::wcursyncup(w); } 1271 // Position the cursor in all ancestor windows corresponding to our setting 1272 1273 int syncok(bool bf) { return ::syncok(w, bf); } 1274 // If called with bf=TRUE, syncup() is called whenever the window is changed 1275 1276 #ifndef _no_flushok 1277 int flushok(bool bf) { return ::flushok(w, bf); } 1278 #endif 1279 1280 void immedok(bool bf) { ::immedok(w, bf); } 1281 // If called with bf=TRUE, any change in the window will cause an 1282 // automatic immediate refresh() 1283 1284 int intrflush(bool bf) { return ::intrflush(w, bf); } 1285 1286 int keypad(bool bf) { return ::keypad(w, bf); } 1287 // If called with bf=TRUE, the application will interpret function keys. 1288 1289 int nodelay(bool bf) { return ::nodelay(w, bf); } 1290 1291 int meta(bool bf) { return ::meta(w, bf); } 1292 // If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise 1293 // 7-Bit characters are generated. 1294 1295 int standout() { return ::wstandout(w); } 1296 // Enable "standout" attributes 1297 1298 int standend() { return ::wstandend(w); } 1299 // Disable "standout" attributes 1300 1301 // ------------------------------------------------------------------------- 1302 // The next two are virtual, because we redefine them in the 1303 // NCursesPanel class. 1304 // ------------------------------------------------------------------------- 1305 virtual int refresh() { return ::wrefresh(w); } 1306 // Propagate the changes in this window to the virtual screen and call 1307 // doupdate(). This is redefined in NCursesPanel. 1308 1309 virtual int noutrefresh() { return ::wnoutrefresh(w); } 1310 // Propagate the changes in this window to the virtual screen. This is 1311 // redefined in NCursesPanel. 1312 1313 // ------------------------------------------------------------------------- 1314 // multiple window control 1315 // ------------------------------------------------------------------------- 1316 int overlay(NCursesWindow& win) { 1317 return ::overlay(w, win.w); } 1318 // Overlay this window over win. 1319 1320 int overwrite(NCursesWindow& win) { 1321 return ::overwrite(w, win.w); } 1322 // Overwrite win with this window. 1323 1324 int copywin(NCursesWindow& win, 1325 int sminrow, int smincol, 1326 int dminrow, int dmincol, 1327 int dmaxrow, int dmaxcol, bool overlaywin=TRUE) { 1328 return ::copywin(w, win.w, sminrow, smincol, dminrow, dmincol, 1329 dmaxrow, dmaxcol, static_cast<int>(overlaywin ? 1 : 0)); } 1330 // Overlay or overwrite the rectangle in win given by dminrow,dmincol, 1331 // dmaxrow,dmaxcol with the rectangle in this window beginning at 1332 // sminrow,smincol. 1333 1334 // ------------------------------------------------------------------------- 1335 // Extended functions 1336 // ------------------------------------------------------------------------- 1337 #if defined(NCURSES_EXT_FUNCS) && (NCURSES_EXT_FUNCS != 0) 1338 int wresize(int newLines, int newColumns) { 1339 return ::wresize(w, newLines, newColumns); } 1340 #endif 1341 1342 // ------------------------------------------------------------------------- 1343 // Mouse related 1344 // ------------------------------------------------------------------------- 1345 bool has_mouse() const; 1346 // Return TRUE if terminal supports a mouse, FALSE otherwise 1347 1348 // ------------------------------------------------------------------------- 1349 // traversal support 1350 // ------------------------------------------------------------------------- 1351 NCursesWindow* child() { return subwins; } 1352 // Get the first child window. 1353 1354 NCursesWindow* sibling() { return sib; } 1355 // Get the next child of my parent. 1356 1357 NCursesWindow* parent() { return par; } 1358 // Get my parent. 1359 1360 bool isDescendant(NCursesWindow& win); 1361 // Return TRUE if win is a descendant of this. 1362 }; 1363 1364 // ------------------------------------------------------------------------- 1365 // We leave this here for compatibility reasons. 1366 // ------------------------------------------------------------------------- 1367 class NCURSES_IMPEXP NCursesColorWindow : public NCursesWindow 1368 { 1369 public: 1370 NCursesColorWindow(WINDOW* &window) // useful only for stdscr 1371 : NCursesWindow(window) { 1372 useColors(); } 1373 1374 NCursesColorWindow(int nlines, // number of lines 1375 int ncols, // number of columns 1376 int begin_y, // line origin 1377 int begin_x) // col origin 1378 : NCursesWindow(nlines, ncols, begin_y, begin_x) { 1379 useColors(); } 1380 1381 NCursesColorWindow(NCursesWindow& parentWin,// parent window 1382 int nlines, // number of lines 1383 int ncols, // number of columns 1384 int begin_y, // absolute or relative 1385 int begin_x, // origins: 1386 char absrel = 'a') // if `a', by & bx are 1387 : NCursesWindow(parentWin, 1388 nlines, ncols, // absolute screen pos, 1389 begin_y, begin_x, // else if `r', they are 1390 absrel ) { // relative to par origin 1391 useColors(); } 1392 }; 1393 1394 // These enum definitions really belong inside the NCursesPad class, but only 1395 // recent compilers support that feature. 1396 1397 typedef enum { 1398 REQ_PAD_REFRESH = KEY_MAX + 1, 1399 REQ_PAD_UP, 1400 REQ_PAD_DOWN, 1401 REQ_PAD_LEFT, 1402 REQ_PAD_RIGHT, 1403 REQ_PAD_EXIT 1404 } Pad_Request; 1405 1406 const Pad_Request PAD_LOW = REQ_PAD_REFRESH; // lowest op-code 1407 const Pad_Request PAD_HIGH = REQ_PAD_EXIT; // highest op-code 1408 1409 // ------------------------------------------------------------------------- 1410 // Pad Support. We allow an association of a pad with a "real" window 1411 // through which the pad may be viewed. 1412 // ------------------------------------------------------------------------- 1413 class NCURSES_IMPEXP NCursesPad : public NCursesWindow 1414 { 1415 private: 1416 NCursesWindow* viewWin; // the "viewport" window 1417 NCursesWindow* viewSub; // the "viewport" subwindow 1418 1419 int h_gridsize, v_gridsize; 1420 1421 protected: 1422 int min_row, min_col; // top left row/col of the pads display area 1423 1424 NCursesWindow* Win(void) const { 1425 // Get the window into which the pad should be copied (if any) 1426 return (viewSub?viewSub:(viewWin?viewWin:0)); 1427 } 1428 1429 NCursesWindow* getWindow(void) const { 1430 return viewWin; 1431 } 1432 1433 NCursesWindow* getSubWindow(void) const { 1434 return viewSub; 1435 } 1436 1437 virtual int driver (int key); // Virtualize keystroke key 1438 // The driver translates the keystroke c into an Pad_Request 1439 1440 virtual void OnUnknownOperation(int pad_req) { 1441 ::beep(); 1442 } 1443 // This is called if the driver returns an unknown op-code 1444 1445 virtual void OnNavigationError(int pad_req) { 1446 ::beep(); 1447 } 1448 // This is called if a navigation request couldn't be satisfied 1449 1450 virtual void OnOperation(int pad_req) { 1451 }; 1452 // OnOperation is called if a Pad_Operation was executed and just before 1453 // the refresh() operation is done. 1454 1455 public: 1456 NCursesPad(int nlines, int ncols); 1457 // create a pad with the given size 1458 1459 NCursesPad& operator=(const NCursesPad& rhs) 1460 { 1461 if (this != &rhs) { 1462 *this = rhs; 1463 NCursesWindow::operator=(rhs); 1464 } 1465 return *this; 1466 } 1467 1468 NCursesPad(const NCursesPad& rhs) 1469 : NCursesWindow(rhs), 1470 viewWin(rhs.viewWin), 1471 viewSub(rhs.viewSub), 1472 h_gridsize(rhs.h_gridsize), 1473 v_gridsize(rhs.v_gridsize), 1474 min_row(rhs.min_row), 1475 min_col(rhs.min_col) 1476 { 1477 } 1478 1479 virtual ~NCursesPad() {} 1480 1481 int echochar(const chtype ch) { return ::pechochar(w, ch); } 1482 // Put the attributed character onto the pad and immediately do a 1483 // prefresh(). 1484 1485 int refresh(); 1486 // If a viewport is defined the pad is displayed in this window, otherwise 1487 // this is a noop. 1488 1489 int refresh(int pminrow, int pmincol, 1490 int sminrow, int smincol, 1491 int smaxrow, int smaxcol) { 1492 return ::prefresh(w, pminrow, pmincol, 1493 sminrow, smincol, smaxrow, smaxcol); 1494 } 1495 // The coordinates sminrow,smincol,smaxrow,smaxcol describe a rectangle 1496 // on the screen. <b>refresh</b> copies a rectangle of this size beginning 1497 // with top left corner pminrow,pmincol onto the screen and calls doupdate(). 1498 1499 int noutrefresh(); 1500 // If a viewport is defined the pad is displayed in this window, otherwise 1501 // this is a noop. 1502 1503 int noutrefresh(int pminrow, int pmincol, 1504 int sminrow, int smincol, 1505 int smaxrow, int smaxcol) { 1506 return ::pnoutrefresh(w, pminrow, pmincol, 1507 sminrow, smincol, smaxrow, smaxcol); 1508 } 1509 // Does the same as refresh() but without calling doupdate(). 1510 1511 virtual void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1); 1512 // Add the window "view" as viewing window to the pad. 1513 1514 virtual void setSubWindow(NCursesWindow& sub); 1515 // Use the subwindow "sub" of the viewport window for the actual viewing. 1516 // The full viewport window is usually used to provide some decorations 1517 // like frames, titles etc. 1518 1519 virtual void operator() (void); 1520 // Perform Pad's operation 1521 }; 1522 1523 // A FramedPad is constructed always with a viewport window. This viewport 1524 // will be framed (by a box() command) and the interior of the box is the 1525 // viewport subwindow. On the frame we display scrollbar sliders. 1526 class NCURSES_IMPEXP NCursesFramedPad : public NCursesPad 1527 { 1528 protected: 1529 virtual void OnOperation(int pad_req); 1530 1531 public: 1532 NCursesFramedPad(NCursesWindow& win, int nlines, int ncols, 1533 int v_grid = 1, int h_grid = 1) 1534 : NCursesPad(nlines, ncols) { 1535 NCursesPad::setWindow(win, v_grid, h_grid); 1536 NCursesPad::setSubWindow(*(new NCursesWindow(win))); 1537 } 1538 // Construct the FramedPad with the given Window win as viewport. 1539 1540 virtual ~NCursesFramedPad() { 1541 delete getSubWindow(); 1542 } 1543 1544 void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1) { 1545 err_handler("Operation not allowed"); 1546 } 1547 // Disable this call; the viewport is already defined 1548 1549 void setSubWindow(NCursesWindow& sub) { 1550 err_handler("Operation not allowed"); 1551 } 1552 // Disable this call; the viewport subwindow is already defined 1553 1554 }; 1555 1556 #endif /* NCURSES_CURSESW_H_incl */ 1557
