home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / libg++-2.7.1-bin.lha / lib / g++-include / CursesW.h < prev    next >
C/C++ Source or Header  |  1996-10-12  |  15KB  |  617 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20. #ifndef _CursesWindow_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _CursesWindow_h
  25.  
  26. #include   <_G_config.h>
  27.  
  28. #if defined(__bsdi__) || defined(__NetBSD__) || defined(__FreeBSD__)
  29. #define _begx begx
  30. #define _begy begy
  31. #define _maxx maxx
  32. #define _maxy maxy
  33. #endif
  34.  
  35. #if _G_HAVE_CURSES
  36. // Even many system which mostly have C++-ready header files,
  37. // do not have C++-ready curses.h.
  38. extern "C" {
  39. #include   <curses.h>
  40. }
  41.  
  42. /* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
  43.    Undefine it here, because CursesWindow uses lines as a method.  */
  44. #undef lines
  45.  
  46. // "Convert" macros to inlines, if needed.
  47. #ifdef addch
  48. inline int (addch)(char ch)  { return addch(ch); }
  49. #undef addch
  50. #endif
  51. #ifdef addstr
  52. /* The (char*) cast is to hack around missing const's */
  53. inline int (addstr)(const char * str)  { return addstr((char*)str); }
  54. #undef addstr
  55. #endif
  56. #ifdef clear
  57. inline int (clear)()  { return clear(); }
  58. #undef clear
  59. #endif
  60. #ifdef clearok
  61. inline int (clearok)(WINDOW* win, int bf)  { return clearok(win, bf); }
  62. #undef clearok
  63. #else
  64. extern "C" int clearok(WINDOW*, int);
  65. #endif
  66. #ifdef clrtobot
  67. inline int (clrtobot)()  { return clrtobot(); }
  68. #undef clrtobot
  69. #endif
  70. #ifdef clrtoeol
  71. inline int (clrtoeol)()  { return clrtoeol(); }
  72. #undef clrtoeol
  73. #endif
  74. #ifdef delch
  75. inline int (delch)()  { return delch(); }
  76. #undef delch
  77. #endif
  78. #ifdef deleteln
  79. inline int (deleteln)()  { return deleteln(); }
  80. #undef deleteln
  81. #endif
  82. #ifdef erase
  83. inline int (erase)()  { return erase(); }
  84. #undef erase
  85. #endif
  86. #ifdef flushok
  87. inline int (flushok)(WINDOW* _win, int _bf)  { return flushok(_win, _bf); }
  88. #undef flushok
  89. #else
  90. #define _no_flushok
  91. #endif
  92. #ifdef getch
  93. inline int (getch)()  { return getch(); }
  94. #undef getch
  95. #endif
  96. #ifdef getstr
  97. inline int (getstr)(char *_str)  { return getstr(_str); }
  98. #undef getstr
  99. #endif
  100. #ifdef getyx
  101. inline void (getyx)(WINDOW* win, int& y, int& x) { getyx(win, y, x); }
  102. #undef getyx
  103. #endif
  104. #ifdef inch
  105. inline int (inch)()  { return inch(); }
  106. #undef inch
  107. #endif
  108. #ifdef insch
  109. inline int (insch)(char c)  { return insch(c); }
  110. #undef insch
  111. #endif
  112. #ifdef insertln
  113. inline int (insertln)()  { return insertln(); }
  114. #undef insertln
  115. #endif
  116. #ifdef leaveok
  117. inline int (leaveok)(WINDOW* win, int bf)  { return leaveok(win, bf); }
  118. #undef leaveok
  119. #else
  120. extern "C" int leaveok(WINDOW* win, int bf);
  121. #endif
  122. #ifdef move
  123. inline int (move)(int x, int y)  { return move(x, y); }
  124. #undef move
  125. #endif
  126. #ifdef refresh
  127. inline int (rfresh)()  { return refresh(); }
  128. #undef refresh
  129. #endif
  130. #ifdef scrollok
  131. inline int (scrollok)(WINDOW* win, int bf)  { return scrollok(win, bf); }
  132. #undef scrollok
  133. #else
  134. #ifndef hpux
  135. extern "C" int scrollok(WINDOW*, int);
  136. #else
  137. extern "C" int scrollok(WINDOW*, char);
  138. #endif
  139. #endif
  140. #ifdef standend
  141. inline int (standend)()  { return (int) standend(); }
  142. #undef standend
  143. #endif
  144. #ifdef standout
  145. inline int (standout)()  { return (int) standout(); }
  146. #undef standout
  147. #endif
  148. #ifdef wstandend
  149. inline int (wstandend)(WINDOW *win)  { return wstandend(win); }
  150. #undef wstandend
  151. #endif
  152. #ifdef wstandout
  153. inline int (wstandout)(WINDOW *win)  { return wstandout(win); }
  154. #undef wstandout
  155. #endif
  156. #ifdef winch
  157. inline int (winch)(WINDOW* win) { return winch(win); }
  158. #undef winch
  159. #endif
  160.  
  161. /* deal with conflicting macros in ncurses.h  which is SYSV based*/
  162. #ifdef box
  163. inline int _G_box(WINDOW* win, chtype v, chtype h) {return box(win, v, h); }
  164. #undef box
  165. inline int box(WINDOW* win, chtype v, chtype h) {return _G_box(win, v, h); }
  166. #endif
  167. #ifdef scroll
  168. inline int (scroll)(WINDOW* win) { return scroll(win); }
  169. #undef scroll
  170. #endif
  171. #ifdef touchwin
  172. inline int (touchwin)(WINDOW* win) { return touchwin(win); }
  173. #undef touchwin
  174. #endif
  175.  
  176. #ifdef mvwaddch
  177. inline int (mvwaddch)(WINDOW *win, int y, int x, char ch)
  178. { return mvwaddch(win, y, x, ch); }
  179. #undef mvwaddch
  180. #endif
  181. #ifdef mvwaddstr
  182. inline int (mvwaddstr)(WINDOW *win, int y, int x, const char * str)
  183. { return mvwaddstr(win, y, x, (char*)str); }
  184. #undef mvwaddstr
  185. #endif
  186. #ifdef mvwdelch
  187. inline int (mvwdelch)(WINDOW *win, int y, int x) { return mvwdelch(win, y, x);}
  188. #undef mvwdelch
  189. #endif
  190. #ifdef mvwgetch
  191. inline int (mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
  192. #undef mvwgetch
  193. #endif
  194. #ifdef mvwgetstr
  195. inline int (mvwgetstr)(WINDOW *win, int y, int x, char *str)
  196. {return mvwgetstr(win,y,x, str);}
  197. #undef mvwgetstr
  198. #endif
  199. #ifdef mvwinch
  200. inline int (mvwinch)(WINDOW *win, int y, int x) { return mvwinch(win, y, x);}
  201. #undef mvwinch
  202. #endif
  203. #ifdef mvwinsch
  204. inline int (mvwinsch)(WINDOW *win, int y, int x, char c)
  205. { return mvwinsch(win, y, x, c); }
  206. #undef mvwinsch
  207. #endif
  208.  
  209. #ifdef mvaddch
  210. inline int (mvaddch)(int y, int x, char ch)
  211. { return mvaddch(y, x, ch); }
  212. #undef mvaddch
  213. #endif
  214. #ifdef mvaddstr
  215. inline int (mvaddstr)(int y, int x, const char * str)
  216. { return mvaddstr(y, x, (char*)str); }
  217. #undef mvaddstr
  218. #endif
  219. #ifdef mvdelch
  220. inline int (mvdelch)(int y, int x) { return mvdelch(y, x);}
  221. #undef mvdelch
  222. #endif
  223. #ifdef mvgetch
  224. inline int (mvgetch)(int y, int x) { return mvgetch(y, x);}
  225. #undef mvgetch
  226. #endif
  227. #ifdef mvgetstr
  228. inline int (mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
  229. #undef mvgetstr
  230. #endif
  231. #ifdef mvinch
  232. inline int (mvinch)(int y, int x) { return mvinch(y, x);}
  233. #undef mvinch
  234. #endif
  235. #ifdef mvinsch
  236. inline int (mvinsch)(int y, int x, char c)
  237. { return mvinsch(y, x, c); }
  238. #undef mvinsch
  239. #endif
  240.  
  241. /*
  242.  *
  243.  * C++ class for windows.
  244.  *
  245.  *
  246.  */
  247.  
  248. class CursesWindow 
  249. {
  250. protected:
  251.   static int     count;           // count of all active windows:
  252.                                   //   We rely on the c++ promise that
  253.                                   //   all otherwise uninitialized
  254.                                   //   static class vars are set to 0
  255.  
  256.   WINDOW *       w;               // the curses WINDOW
  257.  
  258.   int            alloced;         // true if we own the WINDOW
  259.  
  260.   CursesWindow*  par;             // parent, if subwindow
  261.   CursesWindow*  subwins;         // head of subwindows list
  262.   CursesWindow*  sib;             // next subwindow of parent
  263.  
  264.   void           kill_subwindows(); // disable all subwindows
  265.  
  266. public:
  267.                  CursesWindow(WINDOW* &window);   // useful only for stdscr
  268.  
  269.                  CursesWindow(int lines,          // number of lines
  270.                               int cols,           // number of columns
  271.                               int begin_y,        // line origin
  272.                               int begin_x);       // col origin
  273.  
  274.                  CursesWindow(CursesWindow& par,  // parent window
  275.                               int lines,          // number of lines
  276.                               int cols,           // number of columns
  277.                               int by,             // absolute or relative
  278.                               int bx,             //   origins:
  279.                               char absrel = 'a'); // if `a', by & bx are
  280.                                                   // absolute screen pos,
  281.                                                   // else if `r', they are
  282.                                                   // relative to par origin
  283.                 ~CursesWindow();
  284.  
  285. // terminal status
  286.   int            lines(); // number of lines on terminal, *not* window
  287.   int            cols();  // number of cols  on terminal, *not* window
  288.  
  289. // window status
  290.   int            height(); // number of lines in this window
  291.   int            width();  // number of cols in this window
  292.   int            begx();   // smallest x coord in window
  293.   int            begy();   // smallest y coord in window
  294.   int            maxx();   // largest  x coord in window
  295.   int            maxy();   // largest  x coord in window
  296.  
  297. // window positioning
  298.   int            move(int y, int x);
  299.  
  300. // coordinate positioning
  301.   void           getyx(int& y, int& x);
  302.   int            mvcur(int sy, int ey, int sx, int ex);
  303.  
  304. // input
  305.   int            getch();
  306.   int            getstr(char * str);
  307.   int            scanw(const char *, ...);
  308.  
  309. // input + positioning
  310.   int            mvgetch(int y, int x);
  311.   int            mvgetstr(int y, int x, char * str);
  312.   int            mvscanw(int, int, const char*, ...);
  313.  
  314. // output
  315.   int            addch(const char ch);
  316.   int            addstr(const char * str);
  317.   int            printw(const char * fmt, ...);
  318.   int            inch();
  319.   int            insch(char c);
  320.   int            insertln();
  321.  
  322. // output + positioning
  323.   int            mvaddch(int y, int x, char ch);
  324.   int            mvaddstr(int y, int x, const char * str);
  325.   int            mvprintw(int y, int x, const char * fmt, ...);
  326.   int            mvinch(int y, int x);
  327.   int            mvinsch(int y, int x, char ch);
  328.  
  329. // borders
  330.   int            box(char vert, char  hor);
  331.  
  332. // erasure
  333.   int            erase();
  334.   int            clear();
  335.   int            clearok(int bf);
  336.   int            clrtobot();
  337.   int            clrtoeol();
  338.   int            delch();
  339.   int            mvdelch(int y, int x);
  340.   int            deleteln();
  341.  
  342. // screen control
  343.   int            scroll();
  344.   int            scrollok(int bf);
  345.   int            touchwin();
  346.   int            refresh();
  347.   int            leaveok(int bf);
  348. #ifndef _no_flushok
  349.   int            flushok(int bf);
  350. #endif
  351.   int            standout();
  352.   int            standend();
  353.  
  354. // multiple window control
  355.   int            overlay(CursesWindow &win);
  356.   int            overwrite(CursesWindow &win);
  357.  
  358.  
  359. // traversal support
  360.   CursesWindow*  child();
  361.   CursesWindow*  sibling();
  362.   CursesWindow*  parent();
  363. };
  364.  
  365.  
  366. #ifdef __amigaos__
  367.  
  368. /* The <curses.h> file in the ixemul environment is a port of the BSD 4.4 lite
  369.    distribution.  This one doesn't have leading underscores on some of the
  370.    __window members. */
  371.  
  372. #define _begx begx
  373. #define _begy begy
  374. #define _maxx maxx
  375. #define _maxy maxy
  376.  
  377. #endif /* __amigaos__ */
  378.  
  379. inline int CursesWindow::begx()
  380. {
  381.   return w->_begx;
  382. }
  383.  
  384. inline int CursesWindow::begy()
  385. {
  386.   return w->_begy;
  387. }
  388.  
  389. inline int CursesWindow::maxx()
  390. {
  391.   return w->_maxx;
  392. }
  393.  
  394. inline int CursesWindow::maxy()
  395. {
  396.   return w->_maxy;
  397. }
  398.  
  399. inline int CursesWindow::height()
  400. {
  401.   return maxy() - begy() + 1;
  402. }
  403.  
  404. inline int CursesWindow::width()
  405. {
  406.   return maxx() - begx() + 1;
  407. }
  408.  
  409. inline int CursesWindow::box(char vert, char  hor)    
  410. {
  411.   return ::box(w, vert, hor); 
  412. }
  413.  
  414. inline int CursesWindow::overlay(CursesWindow &win)         
  415. {
  416.   return ::overlay(w, win.w); 
  417. }
  418.  
  419. inline int CursesWindow::overwrite(CursesWindow &win)       
  420. {
  421.   return ::overwrite(w, win.w); 
  422. }
  423.  
  424. inline int CursesWindow::scroll()                     
  425. {
  426.   return ::scroll(w); 
  427. }
  428.  
  429.  
  430. inline int CursesWindow::touchwin()                   
  431. {
  432.   return ::touchwin(w); 
  433. }
  434.  
  435. inline int CursesWindow::addch(const char ch)         
  436. {
  437.   return ::waddch(w, ch); 
  438. }
  439.  
  440. inline int CursesWindow::addstr(const char * str)     
  441. {
  442.   // The (char*) cast is to hack around prototypes in curses.h that
  443.   // have const missing in the parameter lists.  [E.g. SVR4]
  444.   return ::waddstr(w, (char*)str); 
  445. }
  446.  
  447. inline int CursesWindow::clear()                      
  448. {
  449.   return ::wclear(w); 
  450. }
  451.  
  452. inline int CursesWindow::clrtobot()                   
  453. {
  454.   return ::wclrtobot(w); 
  455. }
  456.  
  457. inline int CursesWindow::clrtoeol()                   
  458. {
  459.   return ::wclrtoeol(w); 
  460. }
  461.  
  462. inline int CursesWindow::delch()                      
  463. {
  464.   return ::wdelch(w); 
  465. }
  466.  
  467. inline int CursesWindow::deleteln()                   
  468. {
  469.   return ::wdeleteln(w); 
  470. }
  471.  
  472. inline int CursesWindow::erase()                      
  473. {
  474.   return ::werase(w); 
  475. }
  476.  
  477. inline int CursesWindow::getch()                      
  478. {
  479.   return ::wgetch(w); 
  480. }
  481.  
  482. inline int CursesWindow::getstr(char * str)           
  483. {
  484.   return ::wgetstr(w, str); 
  485. }
  486.  
  487. inline int CursesWindow::inch()                       
  488. {
  489.   return winch(w); 
  490. }
  491.  
  492. inline int CursesWindow::insch(char c)               
  493. {
  494.   return ::winsch(w, c); 
  495. }
  496.  
  497. inline int CursesWindow::insertln()                   
  498. {
  499.   return ::winsertln(w); 
  500. }
  501.  
  502. inline int CursesWindow::move(int y, int x)           
  503. {
  504.   return ::wmove(w, y, x); 
  505. }
  506.  
  507.  
  508. inline int CursesWindow::mvcur(int sy, int ey, int sx, int ex)
  509. {
  510.   return ::mvcur(sy, ey, sx,ex);
  511. }
  512.  
  513. inline int CursesWindow::mvaddch(int y, int x, char ch)
  514. {
  515.   return (::wmove(w, y, x)==ERR) ? ERR : ::waddch(w, ch);
  516. }
  517.  
  518. inline int CursesWindow::mvgetch(int y, int x)
  519. {
  520.   return (::wmove(w, y, x)==ERR) ? ERR : ::wgetch(w);
  521. }
  522.  
  523. inline int CursesWindow::mvaddstr(int y, int x, const char * str)
  524. {
  525.   return (::wmove(w, y, x)==ERR) ? ERR : ::waddstr(w, (char*)str);
  526. }
  527.  
  528. inline int CursesWindow::mvgetstr(int y, int x, char * str)
  529. {
  530.   return (::wmove(w, y, x)==ERR) ? ERR : ::wgetstr(w, str);
  531. }
  532.  
  533. inline int CursesWindow::mvinch(int y, int x)
  534. {
  535.   return (::wmove(w, y, x)==ERR) ? ERR : ::winch(w);
  536. }
  537.  
  538. inline int CursesWindow::mvdelch(int y, int x)
  539. {
  540.   return (::wmove(w, y, x)==ERR) ? ERR : ::wdelch(w);
  541. }
  542.  
  543. inline int CursesWindow::mvinsch(int y, int x, char ch)
  544. {
  545.   return (::wmove(w, y, x)==ERR) ? ERR : ::winsch(w, ch);
  546. }
  547.  
  548. inline int CursesWindow::refresh()                   
  549. {
  550.   return ::wrefresh(w); 
  551. }
  552.  
  553. inline int CursesWindow::clearok(int bf)             
  554. {
  555.   return ::clearok(w,bf); 
  556. }
  557.  
  558. inline int CursesWindow::leaveok(int bf)             
  559. {
  560.   return ::leaveok(w,bf); 
  561. }
  562.  
  563. inline int CursesWindow::scrollok(int bf)            
  564. {
  565.   return ::scrollok(w,bf); 
  566. }
  567.  
  568. #ifndef _no_flushok
  569. inline int CursesWindow::flushok(int bf)            
  570. {
  571.   return ::flushok(w, bf); 
  572. }
  573. #endif
  574.  
  575. inline void CursesWindow::getyx(int& y, int& x)       
  576. {
  577.   ::getyx(w, y, x); 
  578. }
  579.  
  580. inline int CursesWindow::standout()                   
  581. {
  582.   return (int) ::wstandout(w); 
  583. }
  584.  
  585. inline int CursesWindow::standend()                   
  586. {
  587.   return (int) ::wstandend(w); 
  588. }
  589.  
  590. inline int CursesWindow::lines()                      
  591. {
  592.   return LINES; 
  593. }
  594.  
  595. inline int CursesWindow::cols()                       
  596. {
  597.   return COLS; 
  598. }
  599.  
  600. inline CursesWindow* CursesWindow::child()
  601. {
  602.   return subwins;
  603. }
  604.  
  605. inline CursesWindow* CursesWindow::parent()
  606. {
  607.   return par;
  608. }
  609.  
  610. inline CursesWindow* CursesWindow::sibling()
  611. {
  612.   return sib;
  613. }
  614.  
  615. #endif /* _G_HAVE_CURSES */
  616. #endif
  617.