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 38extern "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 53inline int UNDEF(addch)(chtype ch) { return addch(ch); } 54#undef addch 55#define addch UNDEF(addch) 56#endif 57 58#ifdef addchstr 59inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); } 60#undef addchstr 61#define addchstr UNDEF(addchstr) 62#endif 63 64#ifdef addnstr 65inline 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 72inline int UNDEF(addstr)(const char * str) { return addstr(str); } 73#undef addstr 74#define addstr UNDEF(addstr) 75#endif 76 77#ifdef attroff 78inline int UNDEF(attroff)(chtype at) { return attroff(at); } 79#undef attroff 80#define attroff UNDEF(attroff) 81#endif 82 83#ifdef attron 84inline int UNDEF(attron)(chtype at) { return attron(at); } 85#undef attron 86#define attron UNDEF(attron) 87#endif 88 89#ifdef attrset 90inline chtype UNDEF(attrset)(chtype at) { return attrset(at); } 91#undef attrset 92#define attrset UNDEF(attrset) 93#endif 94 95#ifdef bkgd 96inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); } 97#undef bkgd 98#define bkgd UNDEF(bkgd) 99#endif 100 101#ifdef bkgdset 102inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); } 103#undef bkgdset 104#define bkgdset UNDEF(bkgdset) 105#endif 106 107#ifdef border 108inline 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 115inline 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 121inline 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 128inline int UNDEF(clear)() { return clear(); } 129#undef clear 130#define clear UNDEF(clear) 131#endif 132 133#ifdef clearok 134inline int UNDEF(clearok)(WINDOW* win, bool bf) { return clearok(win, bf); } 135#undef clearok 136#define clearok UNDEF(clearok) 137#else 138extern "C" NCURSES_IMPEXP int NCURSES_API clearok(WINDOW*, bool); 139#endif 140 141#ifdef clrtobot 142inline int UNDEF(clrtobot)() { return clrtobot(); } 143#undef clrtobot 144#define clrtobot UNDEF(clrtobot) 145#endif 146 147#ifdef clrtoeol 148inline int UNDEF(clrtoeol)() { return clrtoeol(); } 149#undef clrtoeol 150#define clrtoeol UNDEF(clrtoeol) 151#endif 152 153#ifdef color_set 154inline 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 160inline int UNDEF(crmode)(void) { return crmode(); } 161#undef crmode 162#define crmode UNDEF(crmode) 163#endif 164 165#ifdef delch 166inline int UNDEF(delch)() { return delch(); } 167#undef delch 168#define delch UNDEF(delch) 169#endif 170 171#ifdef deleteln 172inline int UNDEF(deleteln)() { return deleteln(); } 173#undef deleteln 174#define deleteln UNDEF(deleteln) 175#endif 176 177#ifdef echochar 178inline int UNDEF(echochar)(chtype ch) { return echochar(ch); } 179#undef echochar 180#define echochar UNDEF(echochar) 181#endif 182 183#ifdef erase 184inline int UNDEF(erase)() { return erase(); } 185#undef erase 186#define erase UNDEF(erase) 187#endif 188 189#ifdef fixterm 190inline int UNDEF(fixterm)(void) { return fixterm(); } 191#undef fixterm 192#define fixterm UNDEF(fixterm) 193#endif 194 195#ifdef flushok 196inline 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 205inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); } 206#undef getattrs 207#define getattrs UNDEF(getattrs) 208#endif 209 210#ifdef getbegyx 211inline 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 217inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); } 218#undef getbkgd 219#define getbkgd UNDEF(getbkgd) 220#endif 221 222#ifdef getch 223inline int UNDEF(getch)() { return getch(); } 224#undef getch 225#define getch UNDEF(getch) 226#endif 227 228#ifdef getmaxyx 229inline 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 235inline 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 241inline 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 247inline int UNDEF(getstr)(char *_str) { return getstr(_str); } 248#undef getstr 249#define getstr UNDEF(getstr) 250#endif 251 252#ifdef getyx 253inline 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 260inline 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 266inline chtype UNDEF(inch)() { return inch(); } 267#undef inch 268#define inch UNDEF(inch) 269#endif 270 271#ifdef inchstr 272inline int UNDEF(inchstr)(chtype *str) { return inchstr(str); } 273#undef inchstr 274#define inchstr UNDEF(inchstr) 275#endif 276 277#ifdef innstr 278inline 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 284inline int UNDEF(insch)(chtype c) { return insch(c); } 285#undef insch 286#define insch UNDEF(insch) 287#endif 288 289#ifdef insdelln 290inline int UNDEF(insdelln)(int n) { return insdelln(n); } 291#undef insdelln 292#define insdelln UNDEF(insdelln) 293#endif 294 295#ifdef insertln 296inline int UNDEF(insertln)() { return insertln(); } 297#undef insertln 298#define insertln UNDEF(insertln) 299#endif 300 301#ifdef insnstr 302inline 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 309inline int UNDEF(insstr)(const char *_str) { 310 return insstr(_str); } 311#undef insstr 312#define insstr UNDEF(insstr) 313#endif 314 315#ifdef instr 316inline int UNDEF(instr)(char *_str) { return instr(_str); } 317#undef instr 318#define instr UNDEF(instr) 319#endif 320 321#ifdef intrflush 322inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); } 323#undef intrflush 324#define intrflush UNDEF(intrflush) 325#endif 326 327#ifdef leaveok 328inline int UNDEF(leaveok)(WINDOW* win, bool bf) { return leaveok(win, bf); } 329#undef leaveok 330#define leaveok UNDEF(leaveok) 331#else 332extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf); 333#endif 334 335#ifdef move 336inline 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 342inline 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 349inline 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 356inline 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 363inline 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 371inline 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 377inline 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 383inline 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 390inline 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 396inline 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 402inline 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 409inline 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 416inline 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 423inline 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 430inline 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 437inline 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 444inline 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 451inline 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 458inline 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 465inline 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 473inline 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 480inline 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 486inline 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 493inline 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 500inline 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 507inline 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 514inline 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 520inline 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 526inline 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 533inline 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 540inline 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 547inline 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 554inline 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 561inline void UNDEF(napms)(unsigned long x) { napms(x); } 562#undef napms 563#define napms UNDEF(napms) 564#endif 565 566#ifdef nocrmode 567inline int UNDEF(nocrmode)(void) { return nocrmode(); } 568#undef nocrmode 569#define nocrmode UNDEF(nocrmode) 570#endif 571 572#ifdef nodelay 573inline void UNDEF(nodelay)() { nodelay(); } 574#undef nodelay 575#define nodelay UNDEF(nodelay) 576#endif 577 578#ifdef redrawwin 579inline int UNDEF(redrawwin)(WINDOW *win) { return redrawwin(win); } 580#undef redrawwin 581#define redrawwin UNDEF(redrawwin) 582#endif 583 584#ifdef refresh 585inline int UNDEF(refresh)() { return refresh(); } 586#undef refresh 587#define refresh UNDEF(refresh) 588#endif 589 590#ifdef resetterm 591inline int UNDEF(resetterm)(void) { return resetterm(); } 592#undef resetterm 593#define resetterm UNDEF(resetterm) 594#endif 595 596#ifdef saveterm 597inline int UNDEF(saveterm)(void) { return saveterm(); } 598#undef saveterm 599#define saveterm UNDEF(saveterm) 600#endif 601 602#ifdef scrl 603inline int UNDEF(scrl)(int l) { return scrl(l); } 604#undef scrl 605#define scrl UNDEF(scrl) 606#endif 607 608#ifdef scroll 609inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); } 610#undef scroll 611#define scroll UNDEF(scroll) 612#endif 613 614#ifdef scrollok 615inline 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) 620extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool); 621#else 622extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char); 623#endif 624#endif 625 626#ifdef setscrreg 627inline 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 633inline int UNDEF(standend)() { return standend(); } 634#undef standend 635#define standend UNDEF(standend) 636#endif 637 638#ifdef standout 639inline int UNDEF(standout)() { return standout(); } 640#undef standout 641#define standout UNDEF(standout) 642#endif 643 644#ifdef subpad 645inline 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 652inline void UNDEF(timeout)(int delay) { timeout(delay); } 653#undef timeout 654#define timeout UNDEF(timeout) 655#endif 656 657#ifdef touchline 658inline 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 665inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); } 666#undef touchwin 667#define touchwin UNDEF(touchwin) 668#endif 669 670#ifdef untouchwin 671inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); } 672#undef untouchwin 673#define untouchwin UNDEF(untouchwin) 674#endif 675 676#ifdef vline 677inline 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 683inline 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 689inline 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 695inline 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 701inline 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 707inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); } 708#undef winch 709#define winch UNDEF(winch) 710#endif 711 712#ifdef winchnstr 713inline 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 719inline 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 725inline 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 732inline int UNDEF(wstandend)(WINDOW *win) { return wstandend(win); } 733#undef wstandend 734#define wstandend UNDEF(wstandend) 735#endif 736 737#ifdef wstandout 738inline 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 749extern "C" int _nc_ripoffline(int, int (*init)(WINDOW*, int)); 750extern "C" int _nc_xx_ripoff_init(WINDOW *, int); 751extern "C" int _nc_has_mouse(void); 752 753class NCURSES_IMPEXP NCursesWindow 754{ 755 friend class NCursesMenu; 756 friend class NCursesForm; 757 758private: 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 776protected: 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 800public: 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// ------------------------------------------------------------------------- 1367class NCURSES_IMPEXP NCursesColorWindow : public NCursesWindow 1368{ 1369public: 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// ------------------------------------------------------------------------- 1413class NCURSES_IMPEXP NCursesPad : public NCursesWindow 1414{ 1415private: 1416 NCursesWindow* viewWin; // the "viewport" window 1417 NCursesWindow* viewSub; // the "viewport" subwindow 1418 1419 int h_gridsize, v_gridsize; 1420 1421protected: 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 1455public: 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. 1526class NCURSES_IMPEXP NCursesFramedPad : public NCursesPad 1527{ 1528protected: 1529 virtual void OnOperation(int pad_req); 1530 1531public: 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