c++/cursesw.cc

   1 // * this is for making emacs happy: -*-Mode: 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   modified by Ulrich Drepper  (drepper@karlsruhe.gmd.de)
  20           and Anatoly Ivasyuk (anatoly@nick.csh.rit.edu)
  21
  22   modified by Juergen Pfeifer
  23   and Thomas Dickey (noting that more than 70% of this file has been changed)
  24 */
  25
  26 #include "internal.h"
  27 #include "cursesw.h"
  28
  29 MODULE_ID("$Id: cursesw.cc,v 1.26 2003/10/25 15:02:46 tom Exp $")
  30
  31 #define COLORS_NEED_INITIALIZATION  -1
  32 #define COLORS_NOT_INITIALIZED       0
  33 #define COLORS_MONOCHROME            1
  34 #define COLORS_ARE_REALLY_THERE      2
  35
  36 // declare static variables for the class
  37 long NCursesWindow::count = 0L;
  38 bool NCursesWindow::b_initialized = FALSE;
  39
  40 /*
  41  * The ncurses library has a fallback for vsscanf(), which may work...
  42  */
  43 #if !(USE_STRSTREAM_VSCAN || USE_STRSTREAM_VSCAN_CAST)
  44 #  undef  USE_STDIO_VSCAN
  45 #  define USE_STDIO_VSCAN 1
  46 #endif
  47
  48 #if defined(__GNUG__)
  49 #  ifndef _IO_va_list
  50 #    define _IO_va_list char *
  51 #  endif
  52 #endif
  53
  54 int
  55 NCursesWindow::scanw(const char* fmt, ...)
  56 {
  57     int result = ERR;
  58     char buf[BUFSIZ];
  59
  60     if (::wgetnstr(w, buf, sizeof(buf)) != ERR) {
  61         va_list args;
  62         va_start(args, fmt);
  63 #if USE_STDIO_VSCAN
  64         if (::vsscanf(buf, fmt, args) != -1)
  65             result = OK;
  66 #elif USE_STRSTREAM_VSCAN       /* powerpc, os390 */
  67         strstreambuf ss(buf, sizeof(buf));
  68         if (ss.vscan(fmt, args) != -1)
  69             result = OK;
  70 #elif USE_STRSTREAM_VSCAN_CAST  /* pre-gcc 3.0 */
  71         strstreambuf ss(buf, sizeof(buf));
  72         if (ss.vscan(fmt, (_IO_va_list)args) != -1)
  73             result = OK;
  74 #endif
  75         va_end(args);
  76     }
  77     return result;
  78 }
  79
  80
  81 int
  82 NCursesWindow::scanw(int y, int x, const char* fmt, ...)
  83 {
  84     int result = ERR;
  85     char buf[BUFSIZ];
  86
  87     if (::wmove(w, y, x) != ERR) {
  88         if (::wgetnstr(w, buf, sizeof(buf)) != ERR) {
  89             va_list args;
  90             va_start(args, fmt);
  91 #if USE_STDIO_VSCAN
  92             if (::vsscanf(buf, fmt, args) != -1)
  93                 result = OK;
  94 #elif USE_STRSTREAM_VSCAN       /* powerpc, os390 */
  95             strstreambuf ss(buf, sizeof(buf));
  96             if (ss.vscan(fmt, args) != -1)
  97                 result = OK;
  98 #elif USE_STRSTREAM_VSCAN_CAST  /* pre-gcc 3.0 */
  99             strstreambuf ss(buf, sizeof(buf));
 100             if (ss.vscan(fmt, (_IO_va_list)args) != -1)
 101                 result = OK;
 102 #endif
 103             va_end(args);
 104         }
 105     }
 106     return result;
 107 }
 108
 109
 110 int
 111 NCursesWindow::printw(const char * fmt, ...)
 112 {
 113     va_list args;
 114     va_start(args, fmt);
 115     char buf[BUFSIZ];
 116     ::vsprintf(buf, fmt, args);
 117     va_end(args);
 118     return waddstr(w, buf);
 119 }
 120
 121
 122 int
 123 NCursesWindow::printw(int y, int x, const char * fmt, ...)
 124 {
 125     va_list args;
 126     va_start(args, fmt);
 127     int result = ::wmove(w, y, x);
 128     if (result == OK) {
 129         char buf[BUFSIZ];
 130         ::vsprintf(buf, fmt, args);
 131         result = waddstr(w, buf);
 132     }
 133     va_end(args);
 134     return result;
 135 }
 136
 137
 138 void
 139 NCursesWindow::init(void)
 140 {
 141     leaveok(0);
 142     keypad(1);
 143     meta(1);
 144 }
 145
 146 void
 147 NCursesWindow::err_handler(const char *msg) const THROWS(NCursesException)
 148 {
 149   THROW(new NCursesException(msg));
 150 }
 151
 152 void
 153 NCursesWindow::initialize() {
 154   if (!b_initialized) {
 155     ::initscr();
 156     b_initialized = TRUE;
 157     if (colorInitialized==COLORS_NEED_INITIALIZATION) {
 158       colorInitialized=COLORS_NOT_INITIALIZED;
 159       useColors();
 160     }
 161     ::noecho();
 162     ::cbreak();
 163   }
 164 }
 165
 166 NCursesWindow::NCursesWindow() {
 167   initialize();
 168
 169   w = (WINDOW *)0;
 170   init();
 171   alloced = FALSE;
 172   subwins = par = sib = 0;
 173   count++;
 174 }
 175
 176 NCursesWindow::NCursesWindow(int lines, int cols, int begin_y, int begin_x)
 177 {
 178     initialize();
 179
 180     w = ::newwin(lines, cols, begin_y, begin_x);
 181     if (w == 0) {
 182         err_handler("Cannot construct window");
 183     }
 184     init();
 185
 186     alloced = TRUE;
 187     subwins = par = sib = 0;
 188     count++;
 189 }
 190
 191 NCursesWindow::NCursesWindow(WINDOW* &window)
 192 {
 193     initialize();
 194
 195     w = window;
 196     init();
 197     alloced = FALSE;
 198     subwins = par = sib = 0;
 199     count++;
 200 }
 201
 202 NCursesWindow::NCursesWindow(NCursesWindow& win, int l, int c,
 203                              int begin_y, int begin_x, char absrel)
 204 {
 205     initialize();
 206     if (absrel == 'a') { // absolute origin
 207         begin_y -= win.begy();
 208         begin_x -= win.begx();
 209     }
 210
 211     // Even though we treat subwindows as a tree, the standard curses
 212     // library needs the `subwin' call to link to the parent in
 213     // order to correctly perform refreshes, etc.
 214     // Friendly enough, this also works for pads.
 215     w = ::derwin(win.w, l, c, begin_y, begin_x);
 216     if (w == 0) {
 217         err_handler("Cannot construct subwindow");
 218     }
 219
 220     par = &win;
 221     sib = win.subwins;
 222     win.subwins = this;
 223     subwins = 0;
 224     alloced = TRUE;
 225     count++;
 226 }
 227
 228 NCursesWindow::NCursesWindow(NCursesWindow& win,
 229                                 bool do_box NCURSES_PARAM_INIT(TRUE))
 230 {
 231   initialize();
 232   w = :: derwin(win.w,win.height()-2,win.width()-2,1,1);
 233   if (w == 0) {
 234     err_handler("Cannot construct subwindow");
 235   }
 236
 237   par = &win;
 238   sib = win.subwins;
 239   win.subwins = this;
 240   subwins = 0;
 241   alloced = TRUE;
 242   count++;
 243
 244   if (do_box) {
 245     win.box();
 246     win.touchwin();
 247   }
 248 }
 249
 250 NCursesWindow NCursesWindow::Clone() {
 251   WINDOW *d = ::dupwin(w);
 252   NCursesWindow W(d);
 253   W.subwins = subwins;
 254   W.sib = sib;
 255   W.par = par;
 256   W.alloced = alloced;
 257   return W;
 258 }
 259
 260 typedef int (*RIPOFFINIT)(NCursesWindow&);
 261 static RIPOFFINIT R_INIT[5];       // There can't be more
 262 static int r_init_idx   = 0;
 263 static RIPOFFINIT* prip = R_INIT;
 264
 265 extern "C" int _nc_ripoffline(int,int (*init)(WINDOW*,int));
 266
 267 NCursesWindow::NCursesWindow(WINDOW *win, int cols) {
 268   initialize();
 269   w = win;
 270   assert((w->_maxx+1)==cols);
 271   alloced = FALSE;
 272   subwins = par = sib = 0;
 273 }
 274
 275 int NCursesWindow::ripoff_init(WINDOW *w, int cols)
 276 {
 277   int res = ERR;
 278
 279   RIPOFFINIT init = *prip++;
 280   if (init) {
 281     NCursesWindow* W = new NCursesWindow(w,cols);
 282     res = init(*W);
 283   }
 284   return res;
 285 }
 286
 287 int NCursesWindow::ripoffline(int ripoff_lines,
 288                               int (*init)(NCursesWindow& win)) {
 289   int code = ::_nc_ripoffline(ripoff_lines,ripoff_init);
 290   if (code==OK && init && ripoff_lines) {
 291     R_INIT[r_init_idx++] = init;
 292   }
 293   return code;
 294 }
 295
 296 bool
 297 NCursesWindow::isDescendant(NCursesWindow& win) {
 298   for (NCursesWindow* p = subwins; p != NULL; p = p->sib) {
 299     if (p==&win)
 300       return TRUE;
 301     else {
 302       if (p->isDescendant(win))
 303         return TRUE;
 304     }
 305   }
 306   return FALSE;
 307 }
 308
 309 void
 310 NCursesWindow::kill_subwindows()
 311 {
 312     for (NCursesWindow* p = subwins; p != 0; p = p->sib) {
 313         p->kill_subwindows();
 314         if (p->alloced) {
 315             if (p->w != 0)
 316                 ::delwin(p->w);
 317             p->alloced = FALSE;
 318         }
 319         p->w = 0; // cause a run-time error if anyone attempts to use...
 320     }
 321 }
 322
 323
 324 NCursesWindow::~NCursesWindow()
 325 {
 326     kill_subwindows();
 327
 328     if (par != 0) {  // Snip us from the parent's list of subwindows.
 329         NCursesWindow * win = par->subwins;
 330         NCursesWindow * trail = 0;
 331         for (;;) {
 332             if (win == 0)
 333                 break;
 334             else if (win == this) {
 335                 if (trail != 0)
 336                     trail->sib = win->sib;
 337                 else
 338                     par->subwins = win->sib;
 339                 break;
 340             } else {
 341                 trail = win;
 342                 win = win->sib;
 343             }
 344         }
 345     }
 346
 347     if (alloced && w != 0)
 348         ::delwin(w);
 349
 350     if (alloced) {
 351       --count;
 352       if (count == 0) {
 353         ::endwin();
 354       }
 355       else if (count < 0) { // cannot happen!
 356         err_handler("Too many windows destroyed");
 357       }
 358     }
 359 }
 360
 361 // ---------------------------------------------------------------------
 362 // Color stuff
 363 //
 364 int NCursesWindow::colorInitialized = COLORS_NOT_INITIALIZED;
 365
 366 void
 367 NCursesWindow::useColors(void)
 368 {
 369     if (colorInitialized == COLORS_NOT_INITIALIZED) {
 370       if (b_initialized) {
 371         if (::has_colors()) {
 372           ::start_color();
 373           colorInitialized = COLORS_ARE_REALLY_THERE;
 374         }
 375         else
 376           colorInitialized = COLORS_MONOCHROME;
 377       }
 378       else
 379         colorInitialized = COLORS_NEED_INITIALIZATION;
 380     }
 381 }
 382
 383 short
 384 NCursesWindow::getcolor(int getback) const
 385 {
 386     short fore, back;
 387
 388     if (colorInitialized==COLORS_ARE_REALLY_THERE) {
 389       if (::pair_content((short)PAIR_NUMBER(w->_attrs), &fore, &back))
 390         err_handler("Can't get color pair");
 391     }
 392     else {
 393       // Monochrome means white on black
 394       back = COLOR_BLACK;
 395       fore = COLOR_WHITE;
 396     }
 397     return getback ? back : fore;
 398 }
 399
 400 int NCursesWindow::NumberOfColors()
 401 {
 402   if (colorInitialized==COLORS_ARE_REALLY_THERE)
 403     return COLORS;
 404   else
 405     return 1; // monochrome (actually there are two ;-)
 406 }
 407
 408 short
 409 NCursesWindow::getcolor() const
 410 {
 411   if (colorInitialized==COLORS_ARE_REALLY_THERE)
 412     return PAIR_NUMBER(w->_attrs);
 413   else
 414     return 0; // we only have pair zero
 415 }
 416
 417 int
 418 NCursesWindow::setpalette(short fore, short back, short pair)
 419 {
 420   if (colorInitialized==COLORS_ARE_REALLY_THERE)
 421     return ::init_pair(pair, fore, back);
 422   else
 423     return OK;
 424 }
 425
 426 int
 427 NCursesWindow::setpalette(short fore, short back)
 428 {
 429   if (colorInitialized==COLORS_ARE_REALLY_THERE)
 430     return setpalette(fore, back, (short)PAIR_NUMBER(w->_attrs));
 431   else
 432     return OK;
 433 }
 434
 435
 436 int
 437 NCursesWindow::setcolor(short pair)
 438 {
 439   if (colorInitialized==COLORS_ARE_REALLY_THERE) {
 440     if ((pair < 1) || (pair > COLOR_PAIRS))
 441       err_handler("Can't set color pair");
 442
 443     attroff(A_COLOR);
 444     attrset(COLOR_PAIR(pair));
 445   }
 446   return OK;
 447 }
 448
 449 #if HAVE_HAS_KEY
 450 extern "C" int _nc_has_mouse(void);
 451
 452 bool NCursesWindow::has_mouse() const {
 453   return ((::has_key(KEY_MOUSE) || ::_nc_has_mouse())
 454           ? TRUE : FALSE);
 455 }
 456 #endif