home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0400 / CCE_0423.ZIP / CCE_0423.PD / GPINCL13.ZOO / xcursesw.h < prev    next >
C/C++ Source or Header  |  1992-10-01  |  13KB  |  562 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2.  
  3. /* 
  4. Copyright (C) 1989 Free Software Foundation
  5.     written by Eric Newton (newton@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #ifndef _CursesWindow_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _CursesWindow_h
  25.  
  26. #include   <curses.h>
  27.  
  28. // "Convert" macros to inlines, if needed.
  29. #ifdef addch
  30. inline int (addch)(char ch)  { return addch(ch); }
  31. #undef addch
  32. #endif
  33. #ifdef addstr
  34. /* The (char*) cast is to hack around missing const's */
  35. inline int (addstr)(const char * str)  { return addstr((char*)str); }
  36. #undef addstr
  37. #endif
  38. #ifdef clear
  39. inline int (clear)()  { return clear(); }
  40. #undef clear
  41. #endif
  42. #ifdef clearok
  43. inline int (clearok)(WINDOW* win, int bf)  { return clearok(win, bf); }
  44. #undef clearok
  45. #else
  46. extern "C" int clearok(WINDOW*, int);
  47. #endif
  48. #ifdef clrtobot
  49. inline int (clrtobot)()  { return clrtobot(); }
  50. #undef clrtobot
  51. #endif
  52. #ifdef clrtoeol
  53. inline int (clrtoeol)()  { return clrtoeol(); }
  54. #undef clrtoeol
  55. #endif
  56. #ifdef delch
  57. inline int (delch)()  { return delch(); }
  58. #undef delch
  59. #endif
  60. #ifdef deleteln
  61. inline int (deleteln)()  { return deleteln(); }
  62. #undef deleteln
  63. #endif
  64. #ifdef erase
  65. inline int (erase)()  { return erase(); }
  66. #undef erase
  67. #endif
  68. #ifdef flushok
  69. inline int (flushok)(WINDOW* _win, int _bf)  { return flushok(_win, _bf); }
  70. #undef flushok
  71. #else
  72. #define _no_flushok
  73. #endif
  74. #ifdef getch
  75. inline int (getch)()  { return getch(); }
  76. #undef getch
  77. #endif
  78. #ifdef getstr
  79. inline int (getstr)(char *_str)  { return getstr(_str); }
  80. #undef getstr
  81. #endif
  82. #ifdef getyx
  83. inline void (getyx)(WINDOW* win, int& y, int& x) { getyx(win, y, x); }
  84. #undef getyx
  85. #endif
  86. #ifdef inch
  87. inline int (inch)()  { return inch(); }
  88. #undef inch
  89. #endif
  90. #ifdef insch
  91. inline int (insch)(char c)  { return insch(c); }
  92. #undef insch
  93. #endif
  94. #ifdef insertln
  95. inline int (insertln)()  { return insertln(); }
  96. #undef insertln
  97. #endif
  98. #ifdef leaveok
  99. inline int (leaveok)(WINDOW* win, int bf)  { return leaveok(win, bf); }
  100. #undef leaveok
  101. #else
  102. extern "C" int leaveok(WINDOW* win, int bf);
  103. #endif
  104. #ifdef move
  105. inline int (move)(int x, int y)  { return move(x, y); }
  106. #undef move
  107. #endif
  108. #ifdef refresh
  109. inline int (rfresh)()  { return refresh(); }
  110. #undef refresh
  111. #endif
  112. #ifdef scrollok
  113. inline int (scrollok)(WINDOW* win, int bf)  { return scrollok(win, bf); }
  114. #undef scrollok
  115. #else
  116. #ifndef hpux
  117. extern "C" int scrollok(WINDOW*, int);
  118. #else
  119. extern "C" int scrollok(WINDOW*, char);
  120. #endif
  121. #endif
  122. #ifdef standend
  123. inline int (standend)()  { return standend(); }
  124. #undef standend
  125. #endif
  126. #ifdef standout
  127. inline int (standout)()  { return standout(); }
  128. #undef standout
  129. #endif
  130. #ifdef winch
  131. inline int (winch)(WINDOW* win) { return winch(win); }
  132. #undef winch
  133. #endif
  134.  
  135. #ifdef mvwaddch
  136. inline int (mvwaddch)(WINDOW *win, int y, int x, char ch)
  137. { return mvwaddch(win, y, x, ch); }
  138. #undef mvwaddch
  139. #endif
  140. #ifdef mvwaddstr
  141. inline int (mvwaddstr)(WINDOW *win, int y, int x, const char * str)
  142. { return mvwaddstr(win, y, x, (char*)str); }
  143. #undef mvwaddstr
  144. #endif
  145. #ifdef mvwdelch
  146. inline int (mvwdelch)(WINDOW *win, int y, int x) { return mvwdelch(win, y, x);}
  147. #undef mvwdelch
  148. #endif
  149. #ifdef mvwgetch
  150. inline int (mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
  151. #undef mvwgetch
  152. #endif
  153. #ifdef mvwgetstr
  154. inline int (mvwgetstr)(WINDOW *win, int y, int x, char *str)
  155. {return mvwgetstr(win,y,x, str);}
  156. #undef mvwgetstr
  157. #endif
  158. #ifdef mvwinch
  159. inline int (mvwinch)(WINDOW *win, int y, int x) { return mvwinch(win, y, x);}
  160. #undef mvwinch
  161. #endif
  162. #ifdef mvwinsch
  163. inline int (mvwinsch)(WINDOW *win, int y, int x, char c)
  164. { return mvwinsch(win, y, x, c); }
  165. #undef mvwinsch
  166. #endif
  167.  
  168. #ifdef mvaddch
  169. inline int (mvaddch)(int y, int x, char ch)
  170. { return mvaddch(y, x, ch); }
  171. #undef mvaddch
  172. #endif
  173. #ifdef mvaddstr
  174. inline int (mvaddstr)(int y, int x, const char * str)
  175. { return mvaddstr(y, x, (char*)str); }
  176. #undef mvaddstr
  177. #endif
  178. #ifdef mvdelch
  179. inline int (mvdelch)(int y, int x) { return mvdelch(y, x);}
  180. #undef mvdelch
  181. #endif
  182. #ifdef mvgetch
  183. inline int (mvgetch)(int y, int x) { return mvgetch(y, x);}
  184. #undef mvgetch
  185. #endif
  186. #ifdef mvgetstr
  187. inline int (mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
  188. #undef mvgetstr
  189. #endif
  190. #ifdef mvinch
  191. inline int (mvinch)(int y, int x) { return mvinch(y, x);}
  192. #undef mvinch
  193. #endif
  194. #ifdef mvinsch
  195. inline int (mvinsch)(int y, int x, char c)
  196. { return mvinsch(y, x, c); }
  197. #undef mvinsch
  198. #endif
  199.  
  200. /*
  201.  *
  202.  * C++ class for windows.
  203.  *
  204.  *
  205.  */
  206.  
  207. class CursesWindow 
  208. {
  209. protected:
  210.   static int     count;           // count of all active windows:
  211.                                   //   We rely on the c++ promise that
  212.                                   //   all otherwise uninitialized
  213.                                   //   static class vars are set to 0
  214.  
  215.   WINDOW *       w;               // the curses WINDOW
  216.  
  217.   int            alloced;         // true if we own the WINDOW
  218.  
  219.   CursesWindow*  par;             // parent, if subwindow
  220.   CursesWindow*  subwins;         // head of subwindows list
  221.   CursesWindow*  sib;             // next subwindow of parent
  222.  
  223.   void           kill_subwindows(); // disable all subwindows
  224.  
  225. public:
  226.                  CursesWindow(WINDOW* &window);   // useful only for stdscr
  227.  
  228.                  CursesWindow(int lines,          // number of lines
  229.                               int cols,           // number of columns
  230.                               int begin_y,        // line origin
  231.                               int begin_x);       // col origin
  232.  
  233.                  CursesWindow(CursesWindow& par,  // parent window
  234.                               int lines,          // number of lines
  235.                               int cols,           // number of columns
  236.                               int by,             // absolute or relative
  237.                               int bx,             //   origins:
  238.                               char absrel = 'a'); // if `a', by & bx are
  239.                                                   // absolute screen pos,
  240.                                                   // else if `r', they are
  241.                                                   // relative to par origin
  242.                 ~CursesWindow();
  243.  
  244. // terminal status
  245.   int            lines(); // number of lines on terminal, *not* window
  246.   int            cols();  // number of cols  on terminal, *not* window
  247.  
  248. // window status
  249.   int            height(); // number of lines in this window
  250.   int            width();  // number of cols in this window
  251.   int            begx();   // smallest x coord in window
  252.   int            begy();   // smallest y coord in window
  253.   int            maxx();   // largest  x coord in window
  254.   int            maxy();   // largest  x coord in window
  255.  
  256. // window positioning
  257.   int            move(int y, int x);
  258.  
  259. // coordinate positioning
  260.   void           getyx(int& y, int& x);
  261.   int            mvcur(int sy, int ey, int sx, int ex);
  262.  
  263. // input
  264.   int            getch();
  265.   int            getstr(char * str);
  266.   int            scanw(const char *, ...);
  267.  
  268. // input + positioning
  269.   int            mvgetch(int y, int x);
  270.   int            mvgetstr(int y, int x, char * str);
  271.   int            mvscanw(int, int, const char*, ...);
  272.  
  273. // output
  274.   int            addch(const char ch);
  275.   int            addstr(const char * str);
  276.   int            printw(const char * fmt, ...);
  277.   int            inch();
  278.   int            insch(char c);
  279.   int            insertln();
  280.  
  281. // output + positioning
  282.   int            mvaddch(int y, int x, char ch);
  283.   int            mvaddstr(int y, int x, const char * str);
  284.   int            mvprintw(int y, int x, const char * fmt, ...);
  285.   int            mvinch(int y, int x);
  286.   int            mvinsch(int y, int x, char ch);
  287.  
  288. // borders
  289.   int            box(char vert, char  hor);
  290.  
  291. // erasure
  292.   int            erase();
  293.   int            clear();
  294.   int            clearok(int bf);
  295.   int            clrtobot();
  296.   int            clrtoeol();
  297.   int            delch();
  298.   int            mvdelch(int y, int x);
  299.   int            deleteln();
  300.  
  301. // screen control
  302.   int            scroll();
  303.   int            scrollok(int bf);
  304.   int            touchwin();
  305.   int            refresh();
  306.   int            leaveok(int bf);
  307. #ifndef _no_flushok
  308.   int            flushok(int bf);
  309. #endif
  310.   int            standout();
  311.   int            standend();
  312.  
  313. // multiple window control
  314.   int            overlay(CursesWindow &win);
  315.   int            overwrite(CursesWindow &win);
  316.  
  317.  
  318. // traversal support
  319.   CursesWindow*  child();
  320.   CursesWindow*  sibling();
  321.   CursesWindow*  parent();
  322. };
  323.  
  324.  
  325. inline int CursesWindow::begx()
  326. {
  327.   return w->_begx;
  328. }
  329.  
  330. inline int CursesWindow::begy()
  331. {
  332.   return w->_begy;
  333. }
  334.  
  335. inline int CursesWindow::maxx()
  336. {
  337.   return w->_maxx;
  338. }
  339.  
  340. inline int CursesWindow::maxy()
  341. {
  342.   return w->_maxy;
  343. }
  344.  
  345. inline int CursesWindow::height()
  346. {
  347.   return maxy() - begy() + 1;
  348. }
  349.  
  350. inline int CursesWindow::width()
  351. {
  352.   return maxx() - begx() + 1;
  353. }
  354.  
  355. inline int CursesWindow::box(char vert, char  hor)    
  356. {
  357.   return ::box(w, vert, hor); 
  358. }
  359.  
  360. inline int CursesWindow::overlay(CursesWindow &win)         
  361. {
  362.   return ::overlay(w, win.w); 
  363. }
  364.  
  365. inline int CursesWindow::overwrite(CursesWindow &win)       
  366. {
  367.   return ::overwrite(w, win.w); 
  368. }
  369.  
  370. inline int CursesWindow::scroll()                     
  371. {
  372.   return ::scroll(w); 
  373. }
  374.  
  375.  
  376. inline int CursesWindow::touchwin()                   
  377. {
  378.   return ::touchwin(w); 
  379. }
  380.  
  381. inline int CursesWindow::addch(const char ch)         
  382. {
  383.   return ::waddch(w, ch); 
  384. }
  385.  
  386. inline int CursesWindow::addstr(const char * str)     
  387. {
  388.   // The (char*) cast is to hack around prototypes in curses.h that
  389.   // have const missing in the parameter lists.  [E.g. SVR4]
  390.   return ::waddstr(w, (char*)str); 
  391. }
  392.  
  393. inline int CursesWindow::clear()                      
  394. {
  395.   return ::wclear(w); 
  396. }
  397.  
  398. inline int CursesWindow::clrtobot()                   
  399. {
  400.   return ::wclrtobot(w); 
  401. }
  402.  
  403. inline int CursesWindow::clrtoeol()                   
  404. {
  405.   return ::wclrtoeol(w); 
  406. }
  407.  
  408. inline int CursesWindow::delch()                      
  409. {
  410.   return ::wdelch(w); 
  411. }
  412.  
  413. inline int CursesWindow::deleteln()                   
  414. {
  415.   return ::wdeleteln(w); 
  416. }
  417.  
  418. inline int CursesWindow::erase()                      
  419. {
  420.   return ::werase(w); 
  421. }
  422.  
  423. inline int CursesWindow::getch()                      
  424. {
  425.   return ::wgetch(w); 
  426. }
  427.  
  428. inline int CursesWindow::getstr(char * str)           
  429. {
  430.   return ::wgetstr(w, str); 
  431. }
  432.  
  433. inline int CursesWindow::inch()                       
  434. {
  435.   return winch(w); 
  436. }
  437.  
  438. inline int CursesWindow::insch(char c)               
  439. {
  440.   return ::winsch(w, c); 
  441. }
  442.  
  443. inline int CursesWindow::insertln()                   
  444. {
  445.   return ::winsertln(w); 
  446. }
  447.  
  448. inline int CursesWindow::move(int y, int x)           
  449. {
  450.   return ::wmove(w, y, x); 
  451. }
  452.  
  453.  
  454. inline int CursesWindow::mvcur(int sy, int ey, int sx, int ex)
  455. {
  456.   return ::mvcur(sy, ey, sx,ex);
  457. }
  458.  
  459. inline int CursesWindow::mvaddch(int y, int x, char ch)
  460. {
  461.   return (::wmove(w, y, x)==ERR) ? ERR : ::waddch(w, ch);
  462. }
  463.  
  464. inline int CursesWindow::mvgetch(int y, int x)
  465. {
  466.   return (::wmove(w, y, x)==ERR) ? ERR : ::wgetch(w);
  467. }
  468.  
  469. inline int CursesWindow::mvaddstr(int y, int x, const char * str)
  470. {
  471.   return (::wmove(w, y, x)==ERR) ? ERR : ::waddstr(w, (char*)str);
  472. }
  473.  
  474. inline int CursesWindow::mvgetstr(int y, int x, char * str)
  475. {
  476.   return (::wmove(w, y, x)==ERR) ? ERR : ::wgetstr(w, str);
  477. }
  478.  
  479. inline int CursesWindow::mvinch(int y, int x)
  480. {
  481.   return (::wmove(w, y, x)==ERR) ? ERR : ::winch(w);
  482. }
  483.  
  484. inline int CursesWindow::mvdelch(int y, int x)
  485. {
  486.   return (::wmove(w, y, x)==ERR) ? ERR : ::wdelch(w);
  487. }
  488.  
  489. inline int CursesWindow::mvinsch(int y, int x, char ch)
  490. {
  491.   return (::wmove(w, y, x)==ERR) ? ERR : ::winsch(w, ch);
  492. }
  493.  
  494. inline int CursesWindow::refresh()                   
  495. {
  496.   return ::wrefresh(w); 
  497. }
  498.  
  499. inline int CursesWindow::clearok(int bf)             
  500. {
  501.   return ::clearok(w,bf); 
  502. }
  503.  
  504. inline int CursesWindow::leaveok(int bf)             
  505. {
  506.   return ::leaveok(w,bf); 
  507. }
  508.  
  509. inline int CursesWindow::scrollok(int bf)            
  510. {
  511.   return ::scrollok(w,bf); 
  512. }
  513.  
  514. #ifndef _no_flushok
  515. inline int CursesWindow::flushok(int bf)            
  516. {
  517.   return ::flushok(w, bf); 
  518. }
  519. #endif
  520.  
  521. inline void CursesWindow::getyx(int& y, int& x)       
  522. {
  523.   ::getyx(w, y, x); 
  524. }
  525.  
  526. inline int CursesWindow::standout()                   
  527. {
  528.   return ::wstandout(w); 
  529. }
  530.  
  531. inline int CursesWindow::standend()                   
  532. {
  533.   return ::wstandend(w); 
  534. }
  535.  
  536. inline int CursesWindow::lines()                      
  537. {
  538.   return LINES; 
  539. }
  540.  
  541. inline int CursesWindow::cols()                       
  542. {
  543.   return COLS; 
  544. }
  545.  
  546. inline CursesWindow* CursesWindow::child()
  547. {
  548.   return subwins;
  549. }
  550.  
  551. inline CursesWindow* CursesWindow::parent()
  552. {
  553.   return par;
  554. }
  555.  
  556. inline CursesWindow* CursesWindow::sibling()
  557. {
  558.   return sib;
  559. }
  560.  
  561. #endif
  562.