libyui-ncurses  2.57.2
ncursesw.h
1 /*
2  Copyright (C) 2000-2012 Novell, Inc
3  This library is free software; you can redistribute it and/or modify
4  it under the terms of the GNU Lesser General Public License as
5  published by the Free Software Foundation; either version 2.1 of the
6  License, or (at your option) version 3.0 of the License. This library
7  is distributed in the hope that it will be useful, but WITHOUT ANY
8  WARRANTY; without even the implied warranty of MERCHANTABILITY or
9  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
10  License for more details. You should have received a copy of the GNU
11  Lesser General Public License along with this library; if not, write
12  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
13  Floor, Boston, MA 02110-1301 USA
14 */
15 
16 
17 /*-/
18 
19  File: ncursesw.h
20 
21  Author: Michael Andres <ma@suse.de>
22 
23 /-*/
24 
25 #ifndef _CURSESW_H
26 #define _CURSESW_H
27 
28 #include <iosfwd>
29 
30 #include <ncursesw/curses.h>
31 #ifndef NCURSES_CXX_IMPEXP
32 #define NCURSES_CXX_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
33 #endif
34 #include <ncursesw/etip.h>
35 #include <cstdio>
36 #include <cstdarg>
37 #include <climits>
38 #include "position.h"
39 
40 /* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
41  Undefine it here, because NCursesWindow uses lines as a method. */
42 #undef lines
43 
44 /* "Convert" macros to inlines. We'll define it as another symbol to avoid
45  * conflict with library symbols.
46  */
47 #undef UNDEF
48 #define UNDEF(name) CUR_ ##name
49 
50 #ifdef addch
51 inline int UNDEF( addch )( chtype ch ) { return addch( ch ); }
52 
53 #undef addch
54 #define addch UNDEF(addch)
55 #endif
56 
57 #ifdef add_wch
58 inline int UNDEF( add_wch )( cchar_t * cch ) { return add_wch( cch ); }
59 
60 #undef add_wch
61 #define add_wch UNDEF(add_wch)
62 #endif
63 
64 #ifdef echochar
65 inline int UNDEF( echochar )( chtype ch ) { return echochar( ch ); }
66 
67 #undef echochar
68 #define echochar UNDEF(echochar)
69 #endif
70 
71 #ifdef insdelln
72 inline int UNDEF( insdelln )( int n ) { return insdelln( n ); }
73 
74 #undef insdelln
75 #define insdelln UNDEF(insdelln)
76 #endif
77 
78 #ifdef addstr
79 /* The (char*) cast is to hack around missing const's */
80 inline int UNDEF( addstr )( const char * str ) { return addstr( (char *) str ); }
81 
82 #undef addstr
83 #define addstr UNDEF(addstr)
84 #endif
85 
86 #ifdef addwstr
87 /* The (wchar*_t) cast is to hack around missing const's */
88 inline int UNDEF( addwstr )( const wchar_t * str ) { return addwstr( (wchar_t *) str ); }
89 
90 #undef addwstr
91 #define addwstr UNDEF(addwstr)
92 #endif
93 
94 #ifdef attron
95 inline int UNDEF( attron )( chtype at ) { return attron( at ); }
96 
97 #undef attron
98 #define attron UNDEF(attron)
99 #endif
100 
101 #ifdef attroff
102 inline int UNDEF( attroff )( chtype at ) { return attroff( at ); }
103 
104 #undef attroff
105 #define attroff UNDEF(attroff)
106 #endif
107 
108 #ifdef attrset
109 inline chtype UNDEF( attrset )( chtype at ) { return attrset( at ); }
110 
111 #undef attrset
112 #define attrset UNDEF(attrset)
113 #endif
114 
115 #ifdef border
116 inline int UNDEF( border )( chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br )
117 { return border( ls, rs, ts, bs, tl, tr, bl, br ); }
118 
119 #undef border
120 #define border UNDEF(border)
121 #endif
122 
123 #ifdef box
124 inline int UNDEF( box )( WINDOW *win, int v, int h ) { return box( win, v, h ); }
125 
126 #undef box
127 #define box UNDEF(box)
128 #endif
129 
130 #ifdef mvwhline
131 inline int UNDEF( mvwhline )( WINDOW *win, int y, int x, chtype c, int n )
132 {
133  return mvwhline( win, y, x, c, n );
134 }
135 
136 #undef mvwhline
137 #define mvwhline UNDEF(mvwhline)
138 #endif
139 
140 #ifdef mvwvline
141 inline int UNDEF( mvwvline )( WINDOW *win, int y, int x, chtype c, int n )
142 {
143  return mvwvline( win, y, x, c, n );
144 }
145 
146 #undef mvwvline
147 #define mvwvline UNDEF(mvwvline)
148 #endif
149 
150 #ifdef clear
151 inline int UNDEF( clear )() { return clear(); }
152 
153 #undef clear
154 #define clear UNDEF(clear)
155 #endif
156 
157 #ifdef clearok
158 inline int UNDEF( clearok )( WINDOW* win, bool bf ) { return clearok( win, bf ); }
159 
160 #undef clearok
161 #define clearok UNDEF(clearok)
162 #else
163 extern "C" int clearok( WINDOW*, bool );
164 #endif
165 
166 #ifdef clrtobot
167 inline int UNDEF( clrtobot )() { return clrtobot(); }
168 
169 #undef clrtobot
170 #define clrtobot UNDEF(clrtobot)
171 #endif
172 
173 #ifdef clrtoeol
174 inline int UNDEF( clrtoeol )() { return clrtoeol(); }
175 
176 #undef clrtoeol
177 #define clrtoeol UNDEF(clrtoeol)
178 #endif
179 
180 #ifdef delch
181 inline int UNDEF( delch )() { return delch(); }
182 
183 #undef delch
184 #define delch UNDEF(delch)
185 #endif
186 
187 #ifdef deleteln
188 inline int UNDEF( deleteln )() { return deleteln(); }
189 
190 #undef deleteln
191 #define deleteln UNDEF(deleteln)
192 #endif
193 
194 #ifdef erase
195 inline int UNDEF( erase )() { return erase(); }
196 
197 #undef erase
198 #define erase UNDEF(erase)
199 #endif
200 
201 #ifdef flushok
202 inline int UNDEF( flushok )( WINDOW* _win, bool _bf )
203 {
204  return flushok( _win, _bf );
205 }
206 
207 #undef flushok
208 #define flushok UNDEF(flushok)
209 #else
210 #define _no_flushok
211 #endif
212 
213 #ifdef getch
214 inline int UNDEF( getch )() { return getch(); }
215 
216 #undef getch
217 #define getch UNDEF(getch)
218 #endif
219 
220 #ifdef getstr
221 inline int UNDEF( getstr )( char *_str ) { return getstr( _str ); }
222 
223 #undef getstr
224 #define getstr UNDEF(getstr)
225 #endif
226 
227 #ifdef instr
228 inline int UNDEF( instr )( char *_str ) { return instr( _str ); }
229 
230 #undef instr
231 #define instr UNDEF(instr)
232 #endif
233 
234 #ifdef innstr
235 inline int UNDEF( innstr )( char *_str, int n ) { return innstr( _str, n ); }
236 
237 #undef innstr
238 #define innstr UNDEF(innstr)
239 #endif
240 
241 #ifdef mvwinnstr
242 inline int UNDEF( mvwinnstr )( WINDOW *win, int y, int x, char *_str, int n )
243 {
244  return mvwinnstr( win, y, x, _str, n );
245 }
246 
247 #undef mvwinnstr
248 #define mvwinnstr UNDEF(mvwinnstr)
249 #endif
250 
251 #ifdef mvinnstr
252 inline int UNDEF( mvinnstr )( int y, int x, char *_str, int n )
253 {
254  return mvinnstr( y, x, _str, n );
255 }
256 
257 #undef mvinnstr
258 #define mvinnstr UNDEF(mvinnstr)
259 #endif
260 
261 #ifdef winsstr
262 inline int UNDEF( winsstr )( WINDOW *w, const char *_str )
263 {
264  return winsstr( w, _str );
265 }
266 
267 #undef winsstr
268 #define winsstr UNDEF(winsstr)
269 #endif
270 
271 #ifdef mvwinsstr
272 inline int UNDEF( mvwinsstr )( WINDOW *w, int y, int x, const char *_str )
273 {
274  return mvwinsstr( w, y, x, _str );
275 }
276 
277 #undef mvwinsstr
278 #define mvwinsstr UNDEF(mvwinsstr)
279 #endif
280 
281 #ifdef insstr
282 inline int UNDEF( insstr )( const char *_str )
283 {
284  return insstr( _str );
285 }
286 
287 #undef insstr
288 #define insstr UNDEF(insstr)
289 #endif
290 
291 #ifdef mvinsstr
292 inline int UNDEF( mvinsstr )( int y, int x, const char *_str )
293 {
294  return mvinsstr( y, x, _str );
295 }
296 
297 #undef mvinsstr
298 #define mvinsstr UNDEF(mvinsstr)
299 #endif
300 
301 #ifdef insnstr
302 inline int UNDEF( insnstr )( const char *_str, int n )
303 {
304  return insnstr( _str, n );
305 }
306 
307 #undef insnstr
308 #define insnstr UNDEF(insnstr)
309 #endif
310 
311 #ifdef mvwinsnstr
312 inline int UNDEF( mvwinsnstr )( WINDOW *w, int y, int x, const char *_str, int n )
313 {
314  return mvwinsnstr( w, y, x, _str, n );
315 }
316 
317 #undef mvwinsnstr
318 #define mvwinsnstr UNDEF(mvwinsnstr)
319 #endif
320 
321 #ifdef mvinsnstr
322 inline int UNDEF( mvinsnstr )( int y, int x, const char *_str, int n )
323 {
324  return mvinsnstr( y, x, _str, n );
325 }
326 
327 #undef mvinsnstr
328 #define mvinsnstr UNDEF(mvinsnstr)
329 #endif
330 
331 #ifdef getnstr
332 inline int UNDEF( getnstr )( char *_str, int n ) { return getnstr( _str, n ); }
333 
334 #undef getnstr
335 #define getnstr UNDEF(getnstr)
336 #endif
337 
338 #ifdef getyx
339 inline void UNDEF( getyx )( const WINDOW* win, int& y, int& x )
340 {
341  getyx( win, y, x );
342 }
343 
344 #undef getyx
345 #define getyx UNDEF(getyx)
346 #endif
347 
348 #ifdef getbegyx
349 inline void UNDEF( getbegyx )( WINDOW* win, int& y, int& x ) { getbegyx( win, y, x ); }
350 
351 #undef getbegyx
352 #define getbegyx UNDEF(getbegyx)
353 #endif
354 
355 #ifdef getmaxyx
356 inline void UNDEF( getmaxyx )( WINDOW* win, int& y, int& x ) { getmaxyx( win, y, x ); }
357 
358 #undef getmaxyx
359 #define getmaxyx UNDEF(getmaxyx)
360 #endif
361 
362 #ifdef hline
363 inline int UNDEF( hline )( chtype ch, int n ) { return hline( ch, n ); }
364 
365 #undef hline
366 #define hline UNDEF(hline)
367 #endif
368 
369 #ifdef inch
370 inline chtype UNDEF( inch )() { return inch(); }
371 
372 #undef inch
373 #define inch UNDEF(inch)
374 #endif
375 
376 #ifdef in_wch
377 inline int UNDEF( in_wch )( cchar_t * cch ) { return in_wch( cch ); }
378 
379 #undef in_wch
380 #define in_wch UNDEF(in_wch)
381 #endif
382 
383 #ifdef insch
384 inline int UNDEF( insch )( char c ) { return insch( c ); }
385 
386 #undef insch
387 #define insch UNDEF(insch)
388 #endif
389 
390 #ifdef ins_wch
391 inline int UNDEF( ins_wch )( const cchar_t *c ) { return ins_wch( c ); }
392 
393 #undef ins_wch
394 #define ins_wch UNDEF(ins_wch)
395 #endif
396 
397 #ifdef mvwins_wch
398 inline int UNDEF( mvwins_wch )( WINDOW *w, int y, int x, const cchar_t *cchar ) { return mvwins_wch( w, y, x, cchar ); }
399 
400 #undef mvwins_wch
401 #define mvwins_wch UNDEF(mvwins_wch)
402 #endif
403 
404 #ifdef insertln
405 inline int UNDEF( insertln )() { return insertln(); }
406 
407 #undef insertln
408 #define insertln UNDEF(insertln)
409 #endif
410 
411 #ifdef leaveok
412 inline int UNDEF( leaveok )( WINDOW* win, bool bf ) { return leaveok( win, bf ); }
413 
414 #undef leaveok
415 #define leaveok UNDEF(leaveok)
416 #else
417 extern "C" int leaveok( WINDOW* win, bool bf );
418 #endif
419 
420 #ifdef move
421 inline int UNDEF( move )( int x, int y ) { return move( x, y ); }
422 
423 #undef move
424 #define move UNDEF(move)
425 #endif
426 
427 #ifdef refresh
428 inline int UNDEF( refresh )() { return refresh(); }
429 
430 #undef refresh
431 #define refresh UNDEF(refresh)
432 #endif
433 
434 #ifdef redrawwin
435 inline int UNDEF( redrawwin )( WINDOW *win ) { return redrawwin( win ); }
436 
437 #undef redrawwin
438 #define redrawwin UNDEF(redrawwin)
439 #endif
440 
441 #ifdef scrl
442 inline int UNDEF( scrl )( int l ) { return scrl( l ); }
443 
444 #undef scrl
445 #define scrl UNDEF(scrl)
446 #endif
447 
448 #ifdef scroll
449 inline int UNDEF( scroll )( WINDOW *win ) { return scroll( win ); }
450 
451 #undef scroll
452 #define scroll UNDEF(scroll)
453 #endif
454 
455 #ifdef scrollok
456 inline int UNDEF( scrollok )( WINDOW* win, bool bf ) { return scrollok( win, bf ); }
457 
458 #undef scrollok
459 #define scrollok UNDEF(scrollok)
460 #else
461 #if defined(__NCURSES_H)
462 extern "C" int scrollok( WINDOW*, bool );
463 #else
464 extern "C" int scrollok( WINDOW*, char );
465 #endif
466 #endif
467 
468 #ifdef setscrreg
469 inline int UNDEF( setscrreg )( int t, int b ) { return setscrreg( t, b ); }
470 
471 #undef setscrreg
472 #define setscrreg UNDEF(setscrreg)
473 #endif
474 
475 #ifdef standend
476 inline int UNDEF( standend )() { return standend(); }
477 
478 #undef standend
479 #define standend UNDEF(standend)
480 #endif
481 
482 #ifdef standout
483 inline int UNDEF( standout )() { return standout(); }
484 
485 #undef standout
486 #define standout UNDEF(standout)
487 #endif
488 
489 #ifdef subpad
490 inline WINDOW *UNDEF( subpad )( WINDOW *p, int l, int c, int y, int x )
491 { return derwin( p, l, c, y, x ); }
492 
493 #undef subpad
494 #define subpad UNDEF(subpad)
495 #endif
496 
497 #ifdef timeout
498 #if NCURSES_VERSION_MAJOR < 5
499 inline int UNDEF( timeout )( int delay ) { return timeout( delay ); }
500 
501 #else
502 inline void UNDEF( timeout )( int delay ) { timeout( delay ); }
503 
504 #endif
505 #undef timeout
506 #define timeout UNDEF(timeout)
507 #endif
508 
509 #ifdef touchline
510 inline int UNDEF( touchline )( WINDOW *win, int s, int c )
511 { return touchline( win, s, c ); }
512 
513 #undef touchline
514 #define touchline UNDEF(touchline)
515 #endif
516 
517 #ifdef touchwin
518 inline int UNDEF( touchwin )( WINDOW *win ) { return touchwin( win ); }
519 
520 #undef touchwin
521 #define touchwin UNDEF(touchwin)
522 #endif
523 
524 #ifdef untouchwin
525 inline int UNDEF( untouchwin )( WINDOW *win ) { return untouchwin( win ); }
526 
527 #undef untouchwin
528 #define untouchwin UNDEF(untouchwin)
529 #endif
530 
531 #ifdef vline
532 inline int UNDEF( vline )( chtype ch, int n ) { return vline( ch, n ); }
533 
534 #undef vline
535 #define vline UNDEF(vline)
536 #endif
537 
538 #ifdef waddstr
539 inline int UNDEF( waddstr )( WINDOW *win, char *str ) { return waddstr( win, str ); }
540 
541 #undef waddstr
542 #define waddstr UNDEF(waddstr)
543 #endif
544 
545 #ifdef waddwstr
546 inline int UNDEF( waddwstr )( WINDOW *win, wchar_t *str ) { return waddwstr( win, str ); }
547 
548 #undef waddwstr
549 #define waddwstr UNDEF(waddwstr)
550 #endif
551 
552 #ifdef mvwaddwstr
553 inline int UNDEF( mvwaddwstr )( WINDOW *win, int y, int x, wchar_t *str )
554 { return mvwaddwstr( win, y, x, str ); }
555 
556 #undef mvwaddwstr
557 #define mvwaddwstr UNDEF(mvwaddwstr)
558 #endif
559 
560 #ifdef waddchstr
561 inline int UNDEF( waddchstr )( WINDOW *win, chtype *at ) { return waddchstr( win, at ); }
562 
563 #undef waddchstr
564 #define waddchstr UNDEF(waddchstr)
565 #endif
566 
567 #ifdef wstandend
568 inline int UNDEF( wstandend )( WINDOW *win ) { return wstandend( win ); }
569 
570 #undef wstandend
571 #define wstandend UNDEF(wstandend)
572 #endif
573 
574 #ifdef wstandout
575 inline int UNDEF( wstandout )( WINDOW *win ) { return wstandout( win ); }
576 
577 #undef wstandout
578 #define wstandout UNDEF(wstandout)
579 #endif
580 
581 
582 #ifdef wattroff
583 inline int UNDEF( wattroff )( WINDOW *win, int att ) { return wattroff( win, att ); }
584 
585 #undef wattroff
586 #define wattroff UNDEF(wattroff)
587 #endif
588 
589 #ifdef chgat
590 inline int UNDEF( chgat )( int n, attr_t attr, short color, const void *opts )
591 {
592  return chgat( n, attr, color, opts );
593 }
594 
595 #undef chgat
596 #define chgat UNDEF(chgat)
597 #endif
598 
599 #ifdef mvchgat
600 inline int UNDEF( mvchgat )( int y, int x, int n,
601  attr_t attr, short color, const void *opts )
602 {
603  return mvchgat( y, x, n, attr, color, opts );
604 }
605 
606 #undef mvchgat
607 #define mvchgat UNDEF(mvchgat)
608 #endif
609 
610 #ifdef mvwchgat
611 inline int UNDEF( mvwchgat )( WINDOW *win, int y, int x, int n,
612  attr_t attr, short color, const void *opts )
613 {
614  return mvwchgat( win, y, x, n, attr, color, opts );
615 }
616 
617 #undef mvwchgat
618 #define mvwchgat UNDEF(mvwchgat)
619 #endif
620 
621 #ifdef wattrset
622 inline int UNDEF( wattrset )( WINDOW *win, int att ) { return wattrset( win, att ); }
623 
624 #undef wattrset
625 #define wattrset UNDEF(wattrset)
626 #endif
627 
628 #ifdef winch
629 inline chtype UNDEF( winch )( const WINDOW* win ) { return winch( win ); }
630 
631 #undef winch
632 #define winch UNDEF(winch)
633 #endif
634 
635 #ifdef mvwaddch
636 inline int UNDEF( mvwaddch )( WINDOW *win, int y, int x, const chtype ch )
637 { return mvwaddch( win, y, x, ch ); }
638 
639 #undef mvwaddch
640 #define mvwaddch UNDEF(mvwaddch)
641 #endif
642 
643 #ifdef mvwaddchnstr
644 inline int UNDEF( mvwaddchnstr )( WINDOW *win, int y, int x, chtype *str, int n )
645 { return mvwaddchnstr( win, y, x, str, n ); }
646 
647 #undef mvwaddchnstr
648 #define mvwaddchnstr UNDEF(mvwaddchnstr)
649 #endif
650 
651 #ifdef mvwaddchstr
652 inline int UNDEF( mvwaddchstr )( WINDOW *win, int y, int x, chtype *str )
653 { return mvwaddchstr( win, y, x, str ); }
654 
655 #undef mvwaddchstr
656 #define mvwaddchstr UNDEF(mvwaddchstr)
657 #endif
658 
659 #ifdef addnstr
660 inline int UNDEF( addnstr )( const char *str, int n )
661 { return addnstr( (char *) str, n ); }
662 
663 #undef addnstr
664 #define addnstr UNDEF(addnstr)
665 #endif
666 
667 #ifdef addnwstr
668 inline int UNDEF( addnwstr )( const wchar_t *str, int n )
669 { return addnwstr( (wchar_t *) str, n ); }
670 
671 #undef addnwstr
672 #define addnwstr UNDEF(addnwstr)
673 #endif
674 
675 #ifdef mvwaddnstr
676 inline int UNDEF( mvwaddnstr )( WINDOW *win, int y, int x, const char *str, int n )
677 { return mvwaddnstr( win, y, x, (char *) str, n ); }
678 
679 #undef mvwaddnstr
680 #define mvwaddnstr UNDEF(mvwaddnstr)
681 #endif
682 
683 #ifdef mvwaddnwstr
684 inline int UNDEF( mvwaddnwstr )( WINDOW *win, int y, int x, const wchar_t *str, int n )
685 { return mvwaddnwstr( win, y, x, (wchar_t *) str, n ); }
686 
687 #undef mvwaddnwstr
688 #define mvwaddnwstr UNDEF(mvwaddnwstr)
689 #endif
690 
691 #ifdef mvwaddstr
692 inline int UNDEF( mvwaddstr )( WINDOW *win, int y, int x, const char * str )
693 { return mvwaddstr( win, y, x, (char *) str ); }
694 
695 #undef mvwaddstr
696 #define mvwaddstr UNDEF(mvwaddstr)
697 #endif
698 
699 #ifdef mvwdelch
700 inline int UNDEF( mvwdelch )( WINDOW *win, int y, int x )
701 { return mvwdelch( win, y, x ); }
702 
703 #undef mvwdelch
704 #define mvwdelch UNDEF(mvwdelch)
705 #endif
706 
707 #ifdef mvwgetch
708 inline int UNDEF( mvwgetch )( WINDOW *win, int y, int x ) { return mvwgetch( win, y, x );}
709 
710 #undef mvwgetch
711 #define mvwgetch UNDEF(mvwgetch)
712 #endif
713 
714 #ifdef mvwgetstr
715 inline int UNDEF( mvwgetstr )( WINDOW *win, int y, int x, char *str )
716 {return mvwgetstr( win, y, x, str );}
717 
718 #undef mvwgetstr
719 #define mvwgetstr UNDEF(mvwgetstr)
720 #endif
721 
722 #ifdef mvwgetnstr
723 inline int UNDEF( mvwgetnstr )( WINDOW *win, int y, int x, char *str, int n )
724 {return mvwgetnstr( win, y, x, str, n );}
725 
726 #undef mvwgetnstr
727 #define mvwgetnstr UNDEF(mvwgetnstr)
728 #endif
729 
730 #ifdef mvwinch
731 inline chtype UNDEF( mvwinch )( WINDOW *win, int y, int x )
732 {
733  return mvwinch( win, y, x );
734 }
735 
736 #undef mvwinch
737 #define mvwinch UNDEF(mvwinch)
738 #endif
739 
740 #ifdef mvwin_wch
741 inline int UNDEF( mvwin_wch )( WINDOW *win, int y, int x, cchar_t * cch )
742 {
743  return mvwin_wch( win, y, x, cch );
744 }
745 
746 #undef mvwin_wch
747 #define mvwin_wch UNDEF(mvwin_wch)
748 #endif
749 
750 #ifdef mvwinsch
751 inline int UNDEF( mvwinsch )( WINDOW *win, int y, int x, char c )
752 { return mvwinsch( win, y, x, c ); }
753 
754 #undef mvwinsch
755 #define mvwinsch UNDEF(mvwinsch)
756 #endif
757 
758 #ifdef mvaddch
759 inline int UNDEF( mvaddch )( int y, int x, chtype ch )
760 { return mvaddch( y, x, ch ); }
761 
762 #undef mvaddch
763 #define mvaddch UNDEF(mvaddch)
764 #endif
765 
766 #ifdef mvaddnstr
767 inline int UNDEF( mvaddnstr )( int y, int x, const char *str, int n )
768 { return mvaddnstr( y, x, (char *) str, n ); }
769 
770 #undef mvaddnstr
771 #define mvaddnstr UNDEF(mvaddnstr)
772 #endif
773 
774 #ifdef mvaddstr
775 inline int UNDEF( mvaddstr )( int y, int x, const char * str )
776 { return mvaddstr( y, x, (char *) str ); }
777 
778 #undef mvaddstr
779 #define mvaddstr UNDEF(mvaddstr)
780 #endif
781 
782 #ifdef mvwadd_wch
783 inline int UNDEF( mvwadd_wch )( WINDOW *win, int y, int x, const cchar_t * cch )
784 { return mvwadd_wch( win, y, x, ( cchar_t* )cch ); }
785 
786 #undef mvwadd_wch
787 #define mvwadd_wch UNDEF(mvwadd_wch)
788 #endif
789 
790 #ifdef mvdelch
791 inline int UNDEF( mvdelch )( int y, int x ) { return mvdelch( y, x );}
792 
793 #undef mvdelch
794 #define mvdelch UNDEF(mvdelch)
795 #endif
796 
797 #ifdef mvgetch
798 inline int UNDEF( mvgetch )( int y, int x ) { return mvgetch( y, x );}
799 
800 #undef mvgetch
801 #define mvgetch UNDEF(mvgetch)
802 #endif
803 
804 #ifdef mvgetstr
805 inline int UNDEF( mvgetstr )( int y, int x, char *str ) {return mvgetstr( y, x, str );}
806 
807 #undef mvgetstr
808 #define mvgetstr UNDEF(mvgetstr)
809 #endif
810 
811 #ifdef mvgetnstr
812 inline int UNDEF( mvgetnstr )( int y, int x, char *str, int n )
813 {
814  return mvgetnstr( y, x, str, n );
815 }
816 
817 #undef mvgetnstr
818 #define mvgetnstr UNDEF(mvgetnstr)
819 #endif
820 
821 #ifdef mvinch
822 inline chtype UNDEF( mvinch )( int y, int x ) { return mvinch( y, x );}
823 
824 #undef mvinch
825 #define mvinch UNDEF(mvinch)
826 #endif
827 
828 #ifdef mvinsch
829 inline int UNDEF( mvinsch )( int y, int x, char c )
830 { return mvinsch( y, x, c ); }
831 
832 #undef mvinsch
833 #define mvinsch UNDEF(mvinsch)
834 #endif
835 
836 #ifdef napms
837 inline void UNDEF( napms )( unsigned long x ) { napms( x ); }
838 
839 #undef napms
840 #define napms UNDEF(napms)
841 #endif
842 
843 #ifdef fixterm
844 inline int UNDEF( fixterm )( void ) { return fixterm(); }
845 
846 #undef fixterm
847 #define fixterm UNDEF(fixterm)
848 #endif
849 
850 #ifdef resetterm
851 inline int UNDEF( resetterm )( void ) { return resetterm(); }
852 
853 #undef resetterm
854 #define resetterm UNDEF(resetterm)
855 #endif
856 
857 #ifdef saveterm
858 inline int UNDEF( saveterm )( void ) { return saveterm(); }
859 
860 #undef saveterm
861 #define saveterm UNDEF(saveterm)
862 #endif
863 
864 #ifdef crmode
865 inline int UNDEF( crmode )( void ) { return crmode(); }
866 
867 #undef crmode
868 #define crmode UNDEF(crmode)
869 #endif
870 
871 #ifdef nocrmode
872 inline int UNDEF( nocrmode )( void ) { return nocrmode(); }
873 
874 #undef nocrmode
875 #define nocrmode UNDEF(nocrmode)
876 #endif
877 
878 #ifdef getbkgd
879 inline chtype UNDEF( getbkgd )( const WINDOW *win ) { return getbkgd( win ); }
880 
881 #undef getbkgd
882 #define getbkgd UNDEF(getbkgd)
883 #endif
884 
885 #ifdef bkgd
886 inline int UNDEF( bkgd )( chtype ch ) { return bkgd( ch ); }
887 
888 #undef bkgd
889 #define bkgd UNDEF(bkgd)
890 #endif
891 
892 #ifdef bkgdset
893 inline void UNDEF( bkgdset )( chtype ch ) { bkgdset( ch ); }
894 
895 #undef bkgdset
896 #define bkgdset UNDEF(bkgdset)
897 #endif
898 
899 template <class _Tp> inline int ncursesMaxCoord() { return INT_MAX; }
900 template <> inline int ncursesMaxCoord<short>() { return SHRT_MAX; }
901 
902 /**
903  * @short C++ class for windows.
904 */
905 
906 class NCursesWindow
907 {
908  friend std::ostream & operator<<( std::ostream & Stream, const NCursesWindow & Obj_Cv );
909  friend std::ostream & operator<<( std::ostream & Stream, const NCursesWindow * Obj_Cv );
910 
911  friend class NCursesMenu;
912  friend class NCursesForm;
913 
914 private:
915  static bool b_initialized;
916  static void initialize();
917  static int ripoff_init( WINDOW *, int );
918 
919  void init();
920 
921  short getcolor( int getback ) const;
922 
923  static int setpalette( short fore, short back, short pair );
924  static int colorInitialized;
925 
926  /**
927  * This private constructor is only used during the initialization
928  * of windows generated by ripoffline() calls.
929  */
930  NCursesWindow( WINDOW* win, int cols );
931 
932 protected:
933  /**
934  * Signal an error with the given message text.
935  */
936  void err_handler( const char * ) const THROWS( NCursesException );
937 
938  /**
939  * count of all active windows
940  */
941  static long count;
942  // We rely on the c++ promise that
943  // all otherwise uninitialized
944  // static class vars are set to 0
945 
946  /**
947  * the curses WINDOW
948  */
949  WINDOW* w;
950 
951  /**
952  * TRUE if we own the WINDOW
953  */
954  bool alloced;
955 
956  /**
957  * parent, if subwindow
958  */
959  NCursesWindow* par;
960  /**
961  * head of subwindows std::list
962  */
963  NCursesWindow* subwins;
964  /**
965  * next subwindow of parent
966  */
967  NCursesWindow* sib;
968 
969  /**
970  * Destroy all subwindows.
971  */
972  void kill_subwindows();
973 
974  /**
975  * Only for use by derived classes. They are then in charge to
976  * fill the member variables correctly.
977  */
978  NCursesWindow();
979 
980 public:
981  /**
982  * Constructor. Useful only for stdscr
983  **/
984  NCursesWindow( WINDOW* window );
985 
986  /**
987  * Constructor.
988  **/
989  NCursesWindow( int lines,
990  int cols,
991  int begin_y,
992  int begin_x );
993 
994  /**
995  * Constructor.
996  *
997  * If 'absrel' is 'a', begin_x/y are absolute screen pos,
998  * if `r', they are relative to parent origin.
999  **/
1000  NCursesWindow( NCursesWindow & parent,
1001  int lines,
1002  int cols,
1003  int begin_y,
1004  int begin_x,
1005  char absrel = 'a' );
1006 
1007  /**
1008  * Destructor.
1009  **/
1010  virtual ~NCursesWindow();
1011 
1012  /**
1013  * Make an exact copy of the window.
1014  */
1015  NCursesWindow Clone();
1016 
1017  // -------------------------------------------------------------------------
1018  // Initialization.
1019  // -------------------------------------------------------------------------
1020  /**
1021  * Call this routine very early if you want to have colors.
1022  */
1023  static void useColors( void );
1024 
1025  /**
1026  * This function is used to generate a window of ripped-of lines.
1027  * If the argument is positive, lines are removed from the top, if it
1028  * is negative lines are removed from the bottom. This enhances the
1029  * lowlevel ripoffline() function because it uses the internal
1030  * implementation that allows to remove more than just a single line.
1031  * This function must be called before any other ncurses function. The
1032  * creation of the window is defered until ncurses gets initialized.
1033  * The initialization function is then called.
1034  */
1035  static int ripoffline( int ripoff_lines,
1036  int ( *init )( NCursesWindow& win ) );
1037 
1038  // -------------------------------------------------------------------------
1039  // terminal status
1040  // -------------------------------------------------------------------------
1041  /**
1042  * Number of lines on terminal, *not* window
1043  */
1044  static int lines() { initialize(); return LINES; }
1045 
1046  /**
1047  * Number of cols on terminal, *not* window
1048  */
1049  static int cols() { initialize(); return COLS; }
1050 
1051  /**
1052  * Size of a tab on terminal, *not* window
1053  */
1054  static int tabsize() { initialize(); return TABSIZE; }
1055 
1056  /**
1057  * Number of available colors
1058  */
1059  static int NumberOfColors();
1060 
1061  /**
1062  * Number of available colors
1063  */
1064  int colors() const { return NumberOfColors(); }
1065 
1066  // -------------------------------------------------------------------------
1067  // window status
1068  // -------------------------------------------------------------------------
1069  /**
1070  * Number of lines in this window
1071  */
1072  int height() const { return maxy() + 1; }
1073 
1074  /**
1075  * Number of columns in this window
1076  */
1077  int width() const { return maxx() + 1; }
1078 
1079  /**
1080  * Column of top left corner relative to stdscr
1081  */
1082  int begx() const { return getbegx(w); }
1083 
1084  /**
1085  * Line of top left corner relative to stdscr
1086  */
1087  int begy() const { return getbegy(w); }
1088 
1089  /**
1090  * Largest x coord in window
1091  */
1092  int maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)-1; }
1093 
1094  /**
1095  * Largest y coord in window
1096  */
1097  int maxy() const { return getmaxy(w) == ERR ? ERR : getmaxy(w)-1; }
1098 
1099  /** Ncurses up to ncurses5 internally uses \c short. */
1100  static int maxcoord() { return ncursesMaxCoord<NCURSES_SIZE_T>(); }
1101 
1102  wsze size() const { return wsze( height(), width() ); }
1103 
1104  wpos begpos() const { return wpos( begy(), begx() ); }
1105 
1106  wpos maxpos() const { return wpos( maxy(), maxx() ); }
1107 
1108  wrect area() const { return wrect( begpos(), size() ); }
1109 
1110  /**
1111  * Actual color pair
1112  */
1113  short getcolor() const;
1114 
1115  /**
1116  * Actual foreground color
1117  */
1118  short foreground() const { return getcolor( 0 ); }
1119 
1120  /**
1121  * Actual background color
1122  */
1123  short background() const { return getcolor( 1 ); }
1124 
1125  /**
1126  * Set color palette entry
1127  */
1128  int setpalette( short fore, short back );
1129 
1130  /**
1131  * Set actually used palette entry
1132  */
1133  int setcolor( short pair );
1134 
1135  // -------------------------------------------------------------------------
1136  // window positioning
1137  // -------------------------------------------------------------------------
1138  /**
1139  * Move window to new position with the new position as top left corner.
1140  * This is virtual because it is redefined in NCursesPanel.
1141  */
1142  virtual int mvwin( int begin_y, int begin_x )
1143  {
1144  return ::mvwin( w, begin_y, begin_x );
1145  }
1146 
1147  int mvsubwin( NCursesWindow* sub, int begin_y, int begin_x );
1148 
1149  virtual int resize( int lines, int columns );
1150 
1151  // -------------------------------------------------------------------------
1152  // coordinate positioning
1153  // -------------------------------------------------------------------------
1154  /**
1155  * Move cursor the this position
1156  */
1157  int move( int y, int x ) { return ::wmove( w, y, x ); }
1158 
1159  /**
1160  * Get current position of the cursor
1161  */
1162  void getyx( int& y, int& x ) const { ::getyx( w, y, x ); }
1163 
1164  /**
1165  * Perform lowlevel cursor motion that takes effect immediately.
1166  */
1167  int mvcur( int oldrow, int oldcol, int newrow, int newcol ) const
1168  {
1169  return ::mvcur( oldrow, oldcol, newrow, newcol );
1170  }
1171 
1172  // -------------------------------------------------------------------------
1173  // input
1174  // -------------------------------------------------------------------------
1175 
1176  int nodelay( bool bf ) { return ::nodelay( w, bf ); }
1177 
1178  /**
1179  * Get a keystroke from the window.
1180  */
1181  int getch() { return ::wgetch( w ); }
1182 
1183  /**
1184  * Move cursor to position and get a keystroke from the window
1185  */
1186  int getch( int y, int x ) { return ::mvwgetch( w, y, x ); }
1187 
1188  /**
1189  * Read a series of characters into str until a newline or carriage return
1190  * is received. Read at most n characters. If n is negative, the limit is
1191  * ignored.
1192  */
1193  int getstr( char* str, int n = -1 )
1194  {
1195  return ::wgetnstr( w, str, n );
1196  }
1197 
1198  /**
1199  * Move the cursor to the requested position and then perform the getstr()
1200  * as described above.
1201  */
1202  int getstr( int y, int x, char* str, int n = -1 )
1203  {
1204  return ::mvwgetnstr( w, y, x, str, n );
1205  }
1206 
1207  /**
1208  * Get a std::string of characters from the window into the buffer s. Retrieve
1209  * at most n characters, if n is negative retrieve all characters up to the
1210  * end of the current line. Attributes are stripped from the characters.
1211  */
1212  int instr( char *s, int n = -1 ) { return ::winnstr( w, s, n ); }
1213 
1214  /**
1215  * Move the cursor to the requested position and then perform the instr()
1216  * as described above.
1217  */
1218  int instr( int y, int x, char *s, int n = -1 )
1219  {
1220  return ::mvwinnstr( w, y, x, s, n );
1221  }
1222 
1223 
1224  // -------------------------------------------------------------------------
1225  // output
1226  // -------------------------------------------------------------------------
1227  /**
1228  * Put attributed character to the window.
1229  */
1230  int addch( const char ch )
1231  {
1232  return addch(( const chtype )( ch&A_CHARTEXT ) );
1233  }
1234 
1235  int addch( const chtype ch ) { return ::waddch( w, ch ); }
1236 
1237  /**
1238  * Put attributed character from given position to the window.
1239  */
1240  int add_attr_char( int y, int x );
1241  int add_attr_char();
1242 
1243  /**
1244  * Put a combined character to the window.
1245  */
1246  int add_wch( const cchar_t * cch ) { return ::wadd_wch( w, cch ); }
1247 
1248  int add_wch( int y, int x, const cchar_t * cch ) { return mvwadd_wch( w, y, x, cch ); }
1249 
1250  /**
1251  * Move cursor to the requested position and then put attributed character
1252  * to the window.
1253  */
1254  int addch( int y, int x, const char ch )
1255  {
1256  return addch( y, x, ( const chtype )( ch&A_CHARTEXT ) );
1257  }
1258 
1259  int addch( int y, int x, const chtype ch )
1260  {
1261  return ::mvwaddch( w, y, x, ch );
1262  }
1263 
1264  /**
1265  * Put attributed character to the window and refresh it immediately.
1266  */
1267  int echochar( const char ch )
1268  {
1269  return echochar(( const chtype )( ch&A_CHARTEXT ) );
1270  }
1271 
1272  int echochar( const chtype ch ) { return ::wechochar( w, ch ); }
1273 
1274  /**
1275  * Write the std::string str to the window, stop writing if the terminating
1276  * NUL or the limit n is reached. If n is negative, it is ignored.
1277  */
1278  int addstr( const char* str, int n = -1 )
1279  {
1280  return ::waddnstr( w, (char *) str, n );
1281  }
1282 
1283  /**
1284  * Move the cursor to the requested position and then perform the addstr
1285  * as described above.
1286  */
1287  int addstr( int y, int x, const char * str, int n = -1 )
1288  {
1289  return ::mvwaddnstr( w, y, x, (char *) str, n );
1290  }
1291 
1292  /**
1293  * Write the wchar_t str to the window, stop writing if the terminating
1294  * NUL or the limit n is reached. If n is negative, it is ignored.
1295  */
1296  int addwstr( const wchar_t* str, int n = -1 );
1297 
1298  /**
1299  * Move the cursor to the requested position and then perform the addwstr
1300  * as described above.
1301  */
1302  int addwstr( int y, int x, const wchar_t * str, int n = -1 );
1303 
1304  /**
1305  * Do a formatted print to the window.
1306  */
1307  int printw( const char* fmt, ... )
1308 #if __GNUG__ >= 2
1309  __attribute__(( format( printf, 2, 3 ) ) );
1310 #else
1311  ;
1312 #endif
1313 
1314  /**
1315  * Move the cursor and then do a formatted print to the window.
1316  */
1317  int printw( int y, int x, const char * fmt, ... )
1318 #if __GNUG__ >= 2
1319  __attribute__(( format( printf, 4, 5 ) ) );
1320 #else
1321  ;
1322 #endif
1323 
1324  /**
1325  * Retrieve attributed character under the current cursor position.
1326  */
1327  chtype inch() const { return ::winch( w ); }
1328 
1329  chtype inchar() const { return inch()&( A_CHARTEXT | A_ALTCHARSET ); }
1330 
1331  /**
1332  * Move cursor to requested position and then retrieve attributed character
1333  * at this position.
1334  */
1335  chtype inch( int y, int x ) { return ::mvwinch( w, y, x ); }
1336 
1337  chtype inchar( int y, int x ) { return inch( y, x )&( A_CHARTEXT | A_ALTCHARSET ); }
1338 
1339  /**
1340  * Retrieve combined character under the current cursor position.
1341  */
1342  int in_wchar( cchar_t * cchar );
1343  int in_wchar( int y, int x, cchar_t * cchar );
1344 
1345  /**
1346  * Insert attributed character into the window before current cursor
1347  * position.
1348  */
1349  int insch( chtype ch ) { return ::winsch( w, ch ); }
1350 
1351  /**
1352  * Move cursor to requested position and then insert the attributed
1353  * character before that position.
1354  */
1355  int insch( int y, int x, chtype ch )
1356  {
1357  return ::mvwinsch( w, y, x, ch );
1358  }
1359 
1360  /**
1361  * Move cursor to requested position and then insert the attributed
1362  * character before that position.
1363  */
1364  int ins_wch( int y, int x, const cchar_t * cchar )
1365  {
1366  return mvwins_wch( w, y, x, cchar );
1367  }
1368 
1369  /**
1370  * Insert an empty line above the current line.
1371  */
1372  int insertln() { return ::winsdelln( w, 1 ); }
1373 
1374  /**
1375  * If n>0 insert that many lines above the current line. If n<0 delete
1376  * that many lines beginning with the current line.
1377  */
1378  int insdelln( int n = 1 ) { return ::winsdelln( w, n ); }
1379 
1380  /**
1381  * Insert the std::string into the window before the current cursor position.
1382  * Insert stops at end of std::string or when the limit n is reached. If n is
1383  * negative, it is ignored.
1384  */
1385  int insstr( const char *s, int n = -1 )
1386  {
1387  return ::winsnstr( w, s, n );
1388  }
1389 
1390  /**
1391  * Move the cursor to the requested position and then perform the insstr()
1392  * as described above.
1393  */
1394  int insstr( int y, int x, const char *s, int n = -1 )
1395  {
1396  return ::mvwinsnstr( w, y, x, s, n );
1397  }
1398 
1399  /**
1400  * Switch on the window attributes;
1401  */
1402  int attron( chtype at ) { return ::wattron( w, at ); }
1403 
1404  /**
1405  * Switch off the window attributes;
1406  */
1407  int attroff( chtype at ) { return ::wattroff( w, at ); }
1408 
1409  /**
1410  * Set the window attributes;
1411  */
1412  int attrset( chtype at ) { return ::wattrset( w, at ); }
1413 
1414  /**
1415  * Change the attributes of the next n characters in the current line. If
1416  * n is negative or greater than the number of remaining characters in the
1417  * line, the attributes will be changed up to the end of the line.
1418  */
1419  int chgat( int n, attr_t attr, short color, const void *opts = NULL )
1420  {
1421  return ::wchgat( w, n, attr, color, opts );
1422  }
1423 
1424  /**
1425  * Move the cursor to the requested position and then perform chgat() as
1426  * described above.
1427  */
1428  int chgat( int y, int x,
1429  int n, attr_t attr, short color, const void *opts = NULL )
1430  {
1431  return ::mvwchgat( w, y, x, n, attr, color, opts );
1432  }
1433 
1434  // -------------------------------------------------------------------------
1435  // background
1436  // -------------------------------------------------------------------------
1437  /**
1438  * Get current background setting.
1439  */
1440  chtype getbkgd() const { return ::getbkgd( w ); }
1441 
1442  /**
1443  * Set the background property and apply it to the window.
1444  */
1445  int bkgd( const chtype ch ) { return ::wbkgd( w, ch ); }
1446 
1447  /**
1448  * Set the background property.
1449  */
1450  void bkgdset( chtype ch ) { ::wbkgdset( w, ch ); }
1451 
1452  // -------------------------------------------------------------------------
1453  // borders
1454  // -------------------------------------------------------------------------
1455  /**
1456  * Draw a box around the window with the given vertical and horizontal
1457  * drawing characters. If you specifiy a zero as character, curses will try
1458  * to find a "nice" character.
1459  */
1460  // int box(chtype vert=0, chtype hor=0) {
1461  // return ::wborder(w, vert, vert, hor, hor, 0, 0 ,0, 0); }
1462 
1463  // workaround for 8.1: don't use wborder to draw the box
1464  int box() { return box( wrect( wpos( 0, 0 ), size() ) ); }
1465 
1466  /**
1467  * Draw a border around the window with the given characters for the
1468  * various parts of the border. If you pass zero for a character, curses
1469  * will try to find "nice" characters.
1470  */
1471  int border( chtype left = 0, chtype right = 0,
1472  chtype top = 0, chtype bottom = 0,
1473  chtype top_left = 0, chtype top_right = 0,
1474  chtype bottom_left = 0, chtype bottom_right = 0 )
1475  {
1476  return ::wborder( w, left, right, top, bottom, top_left, top_right,
1477  bottom_left, bottom_right );
1478  }
1479 
1480  // -------------------------------------------------------------------------
1481  // lines and boxes
1482  // -------------------------------------------------------------------------
1483  /**
1484  * Draw a horizontal line of len characters with the given character. If
1485  * you pass zero for the character, curses will try to find a "nice" one.
1486  */
1487  int hline( int len, chtype ch = 0 ) { return ::whline( w, ch, len ); }
1488 
1489  /**
1490  * Move the cursor to the requested position and then draw a horizontal line.
1491  */
1492  int hline( int y, int x, int len, chtype ch = 0 )
1493  {
1494  return ::mvwhline( w, y, x, ch, len );
1495  }
1496 
1497  /**
1498  * Draw a vertical line of len characters with the given character. If
1499  * you pass zero for the character, curses will try to find a "nice" one.
1500  */
1501  int vline( int len, chtype ch = 0 ) { return ::wvline( w, ch, len ); }
1502 
1503  /**
1504  * Move the cursor to the requested position and then draw a vertical line.
1505  */
1506  int vline( int y, int x, int len, chtype ch = 0 )
1507  {
1508  return ::mvwvline( w, y, x, ch, len );
1509  }
1510 
1511  int box( const wrect & dim );
1512 
1513  // -------------------------------------------------------------------------
1514  // erasure
1515  // -------------------------------------------------------------------------
1516  /**
1517  * Erase the window.
1518  */
1519  int erase() { return ::werase( w ); }
1520 
1521  /**
1522  * Clear the window.
1523  */
1524  int clear() { return ::wclear( w ); }
1525 
1526  /**
1527  * Set/Reset the clear flag. If std::set, the next refresh() will clear the
1528  * screen.
1529  */
1530  int clearok( bool bf ) { return ::clearok( w, bf ); }
1531 
1532  /**
1533  * Clear to the end of the window.
1534  */
1535  int clrtobot() { return ::wclrtobot( w ); }
1536 
1537  /**
1538  * Clear to the end of the line.
1539  */
1540  int clrtoeol() { return ::wclrtoeol( w ); }
1541 
1542  /**
1543  * Delete character under the cursor.
1544  */
1545  int delch() { return ::wdelch( w ); }
1546 
1547  /**
1548  * Move cursor to requested position and delete the character under the
1549  * cursor.
1550  */
1551  int delch( int y, int x ) { return ::mvwdelch( w, y, x ); }
1552 
1553  /**
1554  * Delete the current line.
1555  */
1556  int deleteln() { return ::winsdelln( w, -1 ); }
1557 
1558  // -------------------------------------------------------------------------
1559  // screen control
1560  // -------------------------------------------------------------------------
1561  /**
1562  * Scroll amount lines. If amount is positive, scroll up, otherwise
1563  * scroll down.
1564  */
1565  int scroll( int amount = 1 ) { return ::wscrl( w, amount ); }
1566 
1567  /**
1568  * If bf is TRUE, window scrolls if cursor is moved off the bottom
1569  * edge of the window or a scrolling region, otherwise the cursor is left
1570  * at the bottom line.
1571  */
1572  int scrollok( bool bf ) { return ::scrollok( w, bf ); }
1573 
1574  /**
1575  * Define a soft scrolling region.
1576  */
1577  int setscrreg( int from, int to )
1578  {
1579  return ::wsetscrreg( w, from, to );
1580  }
1581 
1582  /**
1583  * If bf is TRUE, use insert/delete line hardware support if possible.
1584  * Otherwise do it in software.
1585  */
1586  int idlok( bool bf ) { return ::idlok( w, bf ); }
1587 
1588  /**
1589  * If bf is TRUE, use insert/delete character hardware support if possible.
1590  * Otherwise do it in software.
1591  */
1592  void idcok( bool bf ) { ::idcok( w, bf ); }
1593 
1594  /**
1595  * Mark the whole window as modified.
1596  */
1597  int touchwin() { return ::wtouchln( w, 0, height(), 1 ); }
1598 
1599  /**
1600  * Mark the whole window as unmodified.
1601  */
1602  int untouchwin() { return ::wtouchln( w, 0, height(), 0 ); }
1603 
1604  /**
1605  * Mark cnt lines beginning from line s as changed or unchanged, depending
1606  * on the value of the changed flag.
1607  */
1608  int touchln( int s, int cnt, bool changed = TRUE )
1609  {
1610  return ::wtouchln( w, s, cnt, (int) ( changed ? 1 : 0 ) );
1611  }
1612 
1613  /**
1614  * Return TRUE if window is marked as changed, FALSE otherwise
1615  */
1616  bool is_wintouched() const
1617  {
1618  return ( ::is_wintouched( w ) ? TRUE : FALSE );
1619  }
1620 
1621  /**
1622  * If bf is TRUE, curses will leave the cursor after an update whereever
1623  * it is after the update.
1624  */
1625  int leaveok( bool bf ) { return ::leaveok( w, bf ); }
1626 
1627  /**
1628  * Redraw n lines starting from the requested line
1629  */
1630  int redrawln( int from, int n ) { return ::wredrawln( w, from, n ); }
1631 
1632  /**
1633  * Redraw the whole window
1634  */
1635  int redrawwin() { return ::wredrawln( w, 0, height() ); }
1636 
1637  /**
1638  * Do all outputs to make the physical screen looking like the virtual one
1639  */
1640  int doupdate() { return ::doupdate(); }
1641 
1642  /**
1643  * Propagate the changes down to all descendant windows
1644  */
1645  void syncdown() { ::wsyncdown( w ); }
1646 
1647  /**
1648  * Propagate the changes up in the hierarchy
1649  */
1650  void syncup() { ::wsyncup( w ); }
1651 
1652  /**
1653  * Position the cursor in all ancestor windows corresponding to our setting
1654  */
1655  void cursyncup() { ::wcursyncup( w ); }
1656 
1657  /**
1658  * If called with bf=TRUE, syncup() is called whenever the window is changed
1659  */
1660  int syncok( bool bf ) { return ::syncok( w, bf ); }
1661 
1662 #ifndef _no_flushok
1663  int flushok( bool bf ) { return ::flushok( w, bf ); }
1664 
1665 #endif
1666 
1667  /**
1668  * If called with bf=TRUE, any change in the window will cause an
1669  * automatic immediate refresh()
1670  */
1671  void immedok( bool bf ) { ::immedok( w, bf ); }
1672 
1673  /**
1674  * If called with bf=TRUE, the application will interpret function keys.
1675  */
1676  int keypad( bool bf ) { return ::keypad( w, bf ); }
1677 
1678  /**
1679  * If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise
1680  * 7-Bit characters are generated.
1681  */
1682  int meta( bool bf ) { return ::meta( w, bf ); }
1683 
1684  /**
1685  * Enable "standout" attributes
1686  */
1687  int standout() { return ::wstandout( w ); }
1688 
1689  /**
1690  * Disable "standout" attributes
1691  */
1692  int standend() { return ::wstandend( w ); }
1693 
1694  // -------------------------------------------------------------------------
1695  // The next two are virtual, because we redefine them in the
1696  // NCursesPanel class.
1697  // -------------------------------------------------------------------------
1698  /**
1699  * Propagate the changes in this window to the virtual screen and call
1700  * doupdate(). This is redefined in NCursesPanel.
1701  */
1702  virtual int refresh() { return ::wrefresh( w ); }
1703 
1704  /**
1705  * Propagate the changes in this window to the virtual screen. This is
1706  * redefined in NCursesPanel.
1707  */
1708  virtual int noutrefresh() { return ::wnoutrefresh( w ); }
1709 
1710  // -------------------------------------------------------------------------
1711  // multiple window control
1712  // -------------------------------------------------------------------------
1713  /**
1714  * Overlay this window over win.
1715  */
1716  int overlay( NCursesWindow& win )
1717  {
1718  return ::overlay( w, win.w );
1719  }
1720 
1721  /**
1722  * Overwrite win with this window.
1723  */
1724  int overwrite( NCursesWindow& win )
1725  {
1726  return ::overwrite( w, win.w );
1727  }
1728 
1729  /**
1730  * Overlay or overwrite the rectangle in win given by dminrow,dmincol,
1731  * dmaxrow,dmaxcol with the rectangle in this window beginning at
1732  * sminrow,smincol.
1733  */
1734  int copywin( NCursesWindow& win,
1735  int sminrow, int smincol,
1736  int dminrow, int dmincol,
1737  int dmaxrow, int dmaxcol, bool overlay = TRUE )
1738  {
1739  return ::copywin( w, win.w, sminrow, smincol, dminrow, dmincol,
1740  dmaxrow, dmaxcol, (int) ( overlay ? 1 : 0 ) );
1741  }
1742 
1743  // -------------------------------------------------------------------------
1744  // Mouse related
1745  // -------------------------------------------------------------------------
1746  /**
1747  * Return TRUE if terminal supports a mouse, FALSE otherwise
1748  */
1749  bool has_mouse() const;
1750 
1751  // -------------------------------------------------------------------------
1752  // traversal support
1753  // -------------------------------------------------------------------------
1754  /**
1755  * Get the first child window.
1756  */
1757  NCursesWindow* child() { return subwins; }
1758 
1759  const NCursesWindow* child() const { return subwins; }
1760 
1761  /**
1762  * Get the next child of my parent.
1763  */
1764  NCursesWindow* sibling() { return sib; }
1765 
1766  const NCursesWindow* sibling() const { return sib; }
1767 
1768  /**
1769  * Get my parent.
1770  */
1771  NCursesWindow* parent() { return par; }
1772 
1773  const NCursesWindow* parent() const { return par; }
1774 
1775  /**
1776  * Return TRUE if win is a descendant of this.
1777  */
1778  bool isDescendant( NCursesWindow& win );
1779 };
1780 
1781 /**
1782  * @short We leave this here for compatibility reasons.
1783 */
1784 
1785 class NCursesColorWindow : public NCursesWindow
1786 {
1787 
1788 public:
1789  /**
1790  * Constructor. Useful only for stdscr
1791  */
1792  NCursesColorWindow( WINDOW* &window )
1793  : NCursesWindow( window )
1794  {
1795  useColors();
1796  }
1797 
1798  /**
1799  * Constructor.
1800  **/
1801  NCursesColorWindow( int lines,
1802  int cols,
1803  int begin_y,
1804  int begin_x )
1805  : NCursesWindow( lines, cols, begin_y, begin_x )
1806  {
1807  useColors();
1808  }
1809 
1810  /**
1811  * Constructor.
1812  *
1813  * If 'absrel' is 'a', begin_x/y are absolute screen pos,
1814  * else if 'r', they are relative to par origin
1815  */
1816  NCursesColorWindow( NCursesWindow& par,
1817  int lines,
1818  int cols,
1819  int begin_y,
1820  int begin_x,
1821  char absrel = 'a' )
1822  : NCursesWindow( par, lines, cols,
1823  begin_y, begin_x,
1824  absrel )
1825  {
1826  useColors();
1827  }
1828 };
1829 
1830 
1831 class NCursesPad : public NCursesWindow
1832 {
1833 
1834 public:
1835  NCursesPad( int lines, int cols );
1836 
1837  /**
1838  * Put the attributed character onto the pad and immediately do a
1839  * prefresh().
1840  */
1841  int echochar( const chtype ch ) { return ::pechochar( w, ch ); }
1842 
1843  /**
1844  * For Pad's we reimplement refresh() and noutrefresh() to do nothing.
1845  * You should call the versions with the argument std::list that are specific
1846  * for Pad's.
1847  */
1848  int refresh() { return OK; };
1849 
1850  int noutrefresh() { return OK; };
1851 
1852  /**
1853  * The coordinates sminrow,smincol,smaxrow,smaxcol describe a rectangle
1854  * on the screen. <b>refresh</b> copies a rectangle of this size beginning
1855  * with top left corner pminrow,pmincol onto the screen and calls doupdate().
1856  */
1857  int refresh( int pminrow, int pmincol,
1858  int sminrow, int smincol,
1859  int smaxrow, int smaxcol )
1860  {
1861  return ::prefresh( w, pminrow, pmincol,
1862  sminrow, smincol, smaxrow, smaxcol );
1863  }
1864 
1865  /**
1866  * Does the same like refresh() but without calling doupdate().
1867  */
1868  int noutrefresh( int pminrow, int pmincol,
1869  int sminrow, int smincol,
1870  int smaxrow, int smaxcol )
1871  {
1872  return ::pnoutrefresh( w, pminrow, pmincol,
1873  sminrow, smincol, smaxrow, smaxcol );
1874  }
1875 };
1876 
1877 #endif // _CURSESW_H
NCursesWindow::lines
static int lines()
Number of lines on terminal, not window.
Definition: ncursesw.h:1044
NCursesWindow::addch
int addch(const char ch)
Put attributed character to the window.
Definition: ncursesw.h:1230
NCursesPad::noutrefresh
int noutrefresh(int pminrow, int pmincol, int sminrow, int smincol, int smaxrow, int smaxcol)
Does the same like refresh() but without calling doupdate().
Definition: ncursesw.h:1868
NCursesWindow::ripoffline
static int ripoffline(int ripoff_lines, int(*init)(NCursesWindow &win))
This function is used to generate a window of ripped-of lines.
Definition: ncursesw.cc:402
wsze
Screen dimension (screen size) in the order height, width: (H, W)
Definition: position.h:154
NCursesWindow::hline
int hline(int len, chtype ch=0)
Draw a horizontal line of len characters with the given character.
Definition: ncursesw.h:1487
NCursesWindow::attrset
int attrset(chtype at)
Set the window attributes;.
Definition: ncursesw.h:1412
NCursesWindow::sibling
NCursesWindow * sibling()
Get the next child of my parent.
Definition: ncursesw.h:1764
NCursesWindow::addstr
int addstr(int y, int x, const char *str, int n=-1)
Move the cursor to the requested position and then perform the addstr as described above.
Definition: ncursesw.h:1287
NCursesWindow::idcok
void idcok(bool bf)
If bf is TRUE, use insert/delete character hardware support if possible.
Definition: ncursesw.h:1592
NCursesWindow::border
int border(chtype left=0, chtype right=0, chtype top=0, chtype bottom=0, chtype top_left=0, chtype top_right=0, chtype bottom_left=0, chtype bottom_right=0)
Draw a border around the window with the given characters for the various parts of the border.
Definition: ncursesw.h:1471
NCursesWindow::colors
int colors() const
Number of available colors.
Definition: ncursesw.h:1064
NCursesWindow::clearok
int clearok(bool bf)
Set/Reset the clear flag.
Definition: ncursesw.h:1530
NCursesWindow::clrtobot
int clrtobot()
Clear to the end of the window.
Definition: ncursesw.h:1535
NCursesWindow::attroff
int attroff(chtype at)
Switch off the window attributes;.
Definition: ncursesw.h:1407
NCursesWindow::parent
NCursesWindow * parent()
Get my parent.
Definition: ncursesw.h:1771
NCursesWindow
C++ class for windows.
Definition: ncursesw.h:907
NCursesWindow::insdelln
int insdelln(int n=1)
If n>0 insert that many lines above the current line.
Definition: ncursesw.h:1378
NCursesWindow::useColors
static void useColors(void)
Call this routine very early if you want to have colors.
Definition: ncursesw.cc:505
NCursesWindow::delch
int delch()
Delete character under the cursor.
Definition: ncursesw.h:1545
NCursesWindow::instr
int instr(char *s, int n=-1)
Get a std::string of characters from the window into the buffer s.
Definition: ncursesw.h:1212
NCursesWindow::addwstr
int addwstr(const wchar_t *str, int n=-1)
Write the wchar_t str to the window, stop writing if the terminating NUL or the limit n is reached.
Definition: ncursesw.cc:124
NCursesWindow::insch
int insch(int y, int x, chtype ch)
Move cursor to requested position and then insert the attributed character before that position.
Definition: ncursesw.h:1355
NCursesWindow::err_handler
void err_handler(const char *) const THROWS(NCursesException)
Signal an error with the given message text.
Definition: ncursesw.cc:231
NCursesWindow::add_attr_char
int add_attr_char(int y, int x)
Put attributed character from given position to the window.
Definition: ncursesw.cc:167
NCursesWindow::getbkgd
chtype getbkgd() const
Get current background setting.
Definition: ncursesw.h:1440
NCursesWindow::deleteln
int deleteln()
Delete the current line.
Definition: ncursesw.h:1556
NCursesWindow::insch
int insch(chtype ch)
Insert attributed character into the window before current cursor position.
Definition: ncursesw.h:1349
NCursesWindow::foreground
short foreground() const
Actual foreground color.
Definition: ncursesw.h:1118
NCursesWindow::getch
int getch()
Get a keystroke from the window.
Definition: ncursesw.h:1181
NCursesWindow::begy
int begy() const
Line of top left corner relative to stdscr.
Definition: ncursesw.h:1087
NCursesWindow::has_mouse
bool has_mouse() const
Return TRUE if terminal supports a mouse, FALSE otherwise.
Definition: ncursesw.cc:595
NCursesPad::echochar
int echochar(const chtype ch)
Put the attributed character onto the pad and immediately do a prefresh().
Definition: ncursesw.h:1841
NCursesWindow::child
NCursesWindow * child()
Get the first child window.
Definition: ncursesw.h:1757
NCursesWindow::addch
int addch(int y, int x, const char ch)
Move cursor to the requested position and then put attributed character to the window.
Definition: ncursesw.h:1254
NCursesWindow::insstr
int insstr(const char *s, int n=-1)
Insert the std::string into the window before the current cursor position.
Definition: ncursesw.h:1385
NCursesWindow::copywin
int copywin(NCursesWindow &win, int sminrow, int smincol, int dminrow, int dmincol, int dmaxrow, int dmaxcol, bool overlay=TRUE)
Overlay or overwrite the rectangle in win given by dminrow,dmincol, dmaxrow,dmaxcol with the rectangl...
Definition: ncursesw.h:1734
NCursesWindow::vline
int vline(int y, int x, int len, chtype ch=0)
Move the cursor to the requested position and then draw a vertical line.
Definition: ncursesw.h:1506
NCursesWindow::mvwin
virtual int mvwin(int begin_y, int begin_x)
Move window to new position with the new position as top left corner.
Definition: ncursesw.h:1142
NCursesWindow::background
short background() const
Actual background color.
Definition: ncursesw.h:1123
NCursesColorWindow::NCursesColorWindow
NCursesColorWindow(WINDOW *&window)
Constructor.
Definition: ncursesw.h:1792
NCursesWindow::getstr
int getstr(char *str, int n=-1)
Read a series of characters into str until a newline or carriage return is received.
Definition: ncursesw.h:1193
NCursesWindow::refresh
virtual int refresh()
Propagate the changes in this window to the virtual screen and call doupdate().
Definition: ncursesw.h:1702
NCursesWindow::clear
int clear()
Clear the window.
Definition: ncursesw.h:1524
NCursesWindow::setscrreg
int setscrreg(int from, int to)
Define a soft scrolling region.
Definition: ncursesw.h:1577
NCursesWindow::cols
static int cols()
Number of cols on terminal, not window.
Definition: ncursesw.h:1049
NCursesWindow::standend
int standend()
Disable "standout" attributes.
Definition: ncursesw.h:1692
NCursesWindow::standout
int standout()
Enable "standout" attributes.
Definition: ncursesw.h:1687
NCursesWindow::attron
int attron(chtype at)
Switch on the window attributes;.
Definition: ncursesw.h:1402
NCursesWindow::w
WINDOW * w
the curses WINDOW
Definition: ncursesw.h:949
NCursesWindow::box
int box()
Draw a box around the window with the given vertical and horizontal drawing characters.
Definition: ncursesw.h:1464
NCursesWindow::setcolor
int setcolor(short pair)
Set actually used palette entry.
Definition: ncursesw.cc:580
NCursesWindow::is_wintouched
bool is_wintouched() const
Return TRUE if window is marked as changed, FALSE otherwise.
Definition: ncursesw.h:1616
NCursesWindow::maxy
int maxy() const
Largest y coord in window.
Definition: ncursesw.h:1097
NCursesWindow::clrtoeol
int clrtoeol()
Clear to the end of the line.
Definition: ncursesw.h:1540
NCursesWindow::meta
int meta(bool bf)
If called with bf=TRUE, keys may generate 8-Bit characters.
Definition: ncursesw.h:1682
NCursesWindow::maxcoord
static int maxcoord()
Ncurses up to ncurses5 internally uses short.
Definition: ncursesw.h:1100
NCursesWindow::overlay
int overlay(NCursesWindow &win)
Overlay this window over win.
Definition: ncursesw.h:1716
NCursesWindow::getcolor
short getcolor() const
Actual color pair.
Definition: ncursesw.cc:553
NCursesWindow::getyx
void getyx(int &y, int &x) const
Get current position of the cursor.
Definition: ncursesw.h:1162
NCursesWindow::par
NCursesWindow * par
parent, if subwindow
Definition: ncursesw.h:959
NCursesPad::noutrefresh
int noutrefresh()
Propagate the changes in this window to the virtual screen.
Definition: ncursesw.h:1850
NCursesWindow::width
int width() const
Number of columns in this window.
Definition: ncursesw.h:1077
NCursesWindow::delch
int delch(int y, int x)
Move cursor to requested position and delete the character under the cursor.
Definition: ncursesw.h:1551
NCursesWindow::instr
int instr(int y, int x, char *s, int n=-1)
Move the cursor to the requested position and then perform the instr() as described above.
Definition: ncursesw.h:1218
NCursesWindow::isDescendant
bool isDescendant(NCursesWindow &win)
Return TRUE if win is a descendant of this.
Definition: ncursesw.cc:416
NCursesWindow::keypad
int keypad(bool bf)
If called with bf=TRUE, the application will interpret function keys.
Definition: ncursesw.h:1676
NCursesWindow::NumberOfColors
static int NumberOfColors()
Number of available colors.
Definition: ncursesw.cc:544
NCursesWindow::kill_subwindows
void kill_subwindows()
Destroy all subwindows.
Definition: ncursesw.cc:433
NCursesWindow::doupdate
int doupdate()
Do all outputs to make the physical screen looking like the virtual one.
Definition: ncursesw.h:1640
NCursesWindow::move
int move(int y, int x)
Move cursor the this position.
Definition: ncursesw.h:1157
NCursesColorWindow::NCursesColorWindow
NCursesColorWindow(int lines, int cols, int begin_y, int begin_x)
Constructor.
Definition: ncursesw.h:1801
NCursesWindow::hline
int hline(int y, int x, int len, chtype ch=0)
Move the cursor to the requested position and then draw a horizontal line.
Definition: ncursesw.h:1492
wpos
Screen position pair in the order line, column: (L, C)
Definition: position.h:110
NCursesWindow::in_wchar
int in_wchar(cchar_t *cchar)
Retrieve combined character under the current cursor position.
Definition: ncursesw.cc:154
NCursesWindow::redrawwin
int redrawwin()
Redraw the whole window.
Definition: ncursesw.h:1635
NCursesWindow::inch
chtype inch() const
Retrieve attributed character under the current cursor position.
Definition: ncursesw.h:1327
NCursesWindow::redrawln
int redrawln(int from, int n)
Redraw n lines starting from the requested line.
Definition: ncursesw.h:1630
NCursesWindow::echochar
int echochar(const char ch)
Put attributed character to the window and refresh it immediately.
Definition: ncursesw.h:1267
NCursesWindow::vline
int vline(int len, chtype ch=0)
Draw a vertical line of len characters with the given character.
Definition: ncursesw.h:1501
NCursesWindow::bkgd
int bkgd(const chtype ch)
Set the background property and apply it to the window.
Definition: ncursesw.h:1445
NCursesWindow::idlok
int idlok(bool bf)
If bf is TRUE, use insert/delete line hardware support if possible.
Definition: ncursesw.h:1586
NCursesColorWindow
We leave this here for compatibility reasons.
Definition: ncursesw.h:1786
NCursesWindow::noutrefresh
virtual int noutrefresh()
Propagate the changes in this window to the virtual screen.
Definition: ncursesw.h:1708
NCursesWindow::immedok
void immedok(bool bf)
If called with bf=TRUE, any change in the window will cause an automatic immediate refresh()
Definition: ncursesw.h:1671
NCursesWindow::tabsize
static int tabsize()
Size of a tab on terminal, not window.
Definition: ncursesw.h:1054
NCursesWindow::touchwin
int touchwin()
Mark the whole window as modified.
Definition: ncursesw.h:1597
NCursesWindow::height
int height() const
Number of lines in this window.
Definition: ncursesw.h:1072
NCursesWindow::ins_wch
int ins_wch(int y, int x, const cchar_t *cchar)
Move cursor to requested position and then insert the attributed character before that position.
Definition: ncursesw.h:1364
NCursesWindow::chgat
int chgat(int n, attr_t attr, short color, const void *opts=NULL)
Change the attributes of the next n characters in the current line.
Definition: ncursesw.h:1419
NCursesWindow::add_wch
int add_wch(const cchar_t *cch)
Put a combined character to the window.
Definition: ncursesw.h:1246
NCursesWindow::subwins
NCursesWindow * subwins
head of subwindows std::list
Definition: ncursesw.h:963
NCursesWindow::erase
int erase()
Erase the window.
Definition: ncursesw.h:1519
NCursesWindow::scroll
int scroll(int amount=1)
Scroll amount lines.
Definition: ncursesw.h:1565
NCursesWindow::chgat
int chgat(int y, int x, int n, attr_t attr, short color, const void *opts=NULL)
Move the cursor to the requested position and then perform chgat() as described above.
Definition: ncursesw.h:1428
NCursesWindow::~NCursesWindow
virtual ~NCursesWindow()
Destructor.
Definition: ncursesw.cc:452
NCursesWindow::leaveok
int leaveok(bool bf)
If bf is TRUE, curses will leave the cursor after an update whereever it is after the update.
Definition: ncursesw.h:1625
NCursesWindow::printw
int printw(const char *fmt,...)
Do a formatted print to the window.
Definition: ncursesw.cc:76
NCursesWindow::begx
int begx() const
Column of top left corner relative to stdscr.
Definition: ncursesw.h:1082
NCursesWindow::count
static long count
count of all active windows
Definition: ncursesw.h:941
NCursesWindow::getch
int getch(int y, int x)
Move cursor to position and get a keystroke from the window.
Definition: ncursesw.h:1186
NCursesPad::refresh
int refresh()
For Pad's we reimplement refresh() and noutrefresh() to do nothing.
Definition: ncursesw.h:1848
NCursesWindow::sib
NCursesWindow * sib
next subwindow of parent
Definition: ncursesw.h:967
NCursesWindow::NCursesWindow
NCursesWindow()
Only for use by derived classes.
Definition: ncursesw.cc:256
NCursesWindow::syncdown
void syncdown()
Propagate the changes down to all descendant windows.
Definition: ncursesw.h:1645
NCursesWindow::alloced
bool alloced
TRUE if we own the WINDOW.
Definition: ncursesw.h:954
NCursesWindow::Clone
NCursesWindow Clone()
Make an exact copy of the window.
Definition: ncursesw.cc:362
NCursesWindow::scrollok
int scrollok(bool bf)
If bf is TRUE, window scrolls if cursor is moved off the bottom edge of the window or a scrolling reg...
Definition: ncursesw.h:1572
NCursesWindow::mvcur
int mvcur(int oldrow, int oldcol, int newrow, int newcol) const
Perform lowlevel cursor motion that takes effect immediately.
Definition: ncursesw.h:1167
NCursesPad::refresh
int refresh(int pminrow, int pmincol, int sminrow, int smincol, int smaxrow, int smaxcol)
The coordinates sminrow,smincol,smaxrow,smaxcol describe a rectangle on the screen.
Definition: ncursesw.h:1857
wrect
A rectangle is defined by its position and size: wpos Pos, wsze Sze.
Definition: position.h:194
NCursesWindow::overwrite
int overwrite(NCursesWindow &win)
Overwrite win with this window.
Definition: ncursesw.h:1724
NCursesWindow::untouchwin
int untouchwin()
Mark the whole window as unmodified.
Definition: ncursesw.h:1602
NCursesPad
Definition: ncursesw.h:1832
NCursesWindow::bkgdset
void bkgdset(chtype ch)
Set the background property.
Definition: ncursesw.h:1450
NCursesWindow::getstr
int getstr(int y, int x, char *str, int n=-1)
Move the cursor to the requested position and then perform the getstr() as described above.
Definition: ncursesw.h:1202
NCursesWindow::insertln
int insertln()
Insert an empty line above the current line.
Definition: ncursesw.h:1372
NCursesWindow::touchln
int touchln(int s, int cnt, bool changed=TRUE)
Mark cnt lines beginning from line s as changed or unchanged, depending on the value of the changed f...
Definition: ncursesw.h:1608
NCursesWindow::syncup
void syncup()
Propagate the changes up in the hierarchy.
Definition: ncursesw.h:1650
NCursesWindow::syncok
int syncok(bool bf)
If called with bf=TRUE, syncup() is called whenever the window is changed.
Definition: ncursesw.h:1660
NCursesWindow::maxx
int maxx() const
Largest x coord in window.
Definition: ncursesw.h:1092
NCursesWindow::inch
chtype inch(int y, int x)
Move cursor to requested position and then retrieve attributed character at this position.
Definition: ncursesw.h:1335
NCursesWindow::addstr
int addstr(const char *str, int n=-1)
Write the std::string str to the window, stop writing if the terminating NUL or the limit n is reache...
Definition: ncursesw.h:1278
NCursesWindow::insstr
int insstr(int y, int x, const char *s, int n=-1)
Move the cursor to the requested position and then perform the insstr() as described above.
Definition: ncursesw.h:1394
NCursesWindow::cursyncup
void cursyncup()
Position the cursor in all ancestor windows corresponding to our setting.
Definition: ncursesw.h:1655
NCursesColorWindow::NCursesColorWindow
NCursesColorWindow(NCursesWindow &par, int lines, int cols, int begin_y, int begin_x, char absrel='a')
Constructor.
Definition: ncursesw.h:1816