ncurses 6.2 - patch 20200308
[ncurses.git] / c++ / cursesw.cc
1 // * this is for making emacs happy: -*-Mode: C++;-*-
2 /****************************************************************************
3  * Copyright 2019,2020 Thomas E. Dickey                                     *
4  * Copyright 1998-2012,2014 Free Software Foundation, Inc.                  *
5  *                                                                          *
6  * Permission is hereby granted, free of charge, to any person obtaining a  *
7  * copy of this software and associated documentation files (the            *
8  * "Software"), to deal in the Software without restriction, including      *
9  * without limitation the rights to use, copy, modify, merge, publish,      *
10  * distribute, distribute with modifications, sublicense, and/or sell       *
11  * copies of the Software, and to permit persons to whom the Software is    *
12  * furnished to do so, subject to the following conditions:                 *
13  *                                                                          *
14  * The above copyright notice and this permission notice shall be included  *
15  * in all copies or substantial portions of the Software.                   *
16  *                                                                          *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
20  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
21  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
22  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
23  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
24  *                                                                          *
25  * Except as contained in this notice, the name(s) of the above copyright   *
26  * holders shall not be used in advertising or otherwise to promote the     *
27  * sale, use or other dealings in this Software without prior written       *
28  * authorization.                                                           *
29  ****************************************************************************/
30
31 /*
32  * Authors:
33  *      Thomas E. Dickey
34  *      Juergen Pfeifer
35  *
36  * The NCursesWindow class was originally based on a file written by
37  * Eric Newton, later modified by Ulrich Drepper and Anatoly Ivasyuk.
38  * However, aside from the compatible interface definition, no trace
39  * of the original code remains in this version: it consists only of
40  * changes introduced since 1995.
41  */
42
43 #include "internal.h"
44 #include "cursesw.h"
45
46 MODULE_ID("$Id: cursesw.cc,v 1.56 2020/02/02 23:34:34 tom Exp $")
47
48 #define COLORS_NEED_INITIALIZATION  -1
49 #define COLORS_NOT_INITIALIZED       0
50 #define COLORS_MONOCHROME            1
51 #define COLORS_ARE_REALLY_THERE      2
52
53 #define HaveColors() (colorInitialized == COLORS_ARE_REALLY_THERE)
54
55 // declare static variables for the class
56 long NCursesWindow::count = 0L;
57 bool NCursesWindow::b_initialized = FALSE;
58
59 int
60 NCursesWindow::scanw(const char* fmt, ...)
61 {
62     int result = ERR;
63
64     va_list args;
65     va_start(args, fmt);
66     result = ::vw_scanw (w, const_cast<NCURSES_CONST char *>(fmt), args);
67     va_end(args);
68
69     return result;
70 }
71
72
73 int
74 NCursesWindow::scanw(int y, int x, const char* fmt, ...)
75 {
76     int result = ERR;
77
78     if (::wmove(w, y, x) != ERR) {
79         va_list args;
80         va_start(args, fmt);
81         result = ::vw_scanw (w, const_cast<NCURSES_CONST char *>(fmt), args);
82         va_end(args);
83     }
84     return result;
85 }
86
87
88 int
89 NCursesWindow::scanw(const char* fmt, va_list args)
90 {
91     int result = ERR;
92
93     result = ::vw_scanw (w, const_cast<NCURSES_CONST char *>(fmt), args);
94
95     return result;
96 }
97
98
99 int
100 NCursesWindow::scanw(int y, int x, const char* fmt, va_list args)
101 {
102     int result = ERR;
103
104     if (::wmove(w, y, x) != ERR) {
105         result = ::vw_scanw (w, const_cast<NCURSES_CONST char *>(fmt), args);
106     }
107     return result;
108 }
109
110
111 int
112 NCursesWindow::printw(const char * fmt, ...)
113 {
114     va_list args;
115     va_start(args, fmt);
116     int result = ::vw_printw(w, fmt, args);
117     va_end(args);
118     return result;
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         result = ::vw_printw(w, fmt, args);
130     }
131     va_end(args);
132     return result;
133 }
134
135
136 int
137 NCursesWindow::printw(const char * fmt, va_list args)
138 {
139     int result = ::vw_printw(w, fmt, args);
140     return result;
141 }
142
143
144 int
145 NCursesWindow::printw(int y, int x, const char * fmt, va_list args)
146 {
147     int result = ::wmove(w, y, x);
148     if (result == OK) {
149         result = ::vw_printw(w, fmt, args);
150     }
151     return result;
152 }
153
154
155 void
156 NCursesWindow::set_keyboard(void)
157 {
158     keypad(TRUE);
159     meta(TRUE);
160 }
161
162 void
163 NCursesWindow::err_handler(const char *msg) const THROWS(NCursesException)
164 {
165   THROW(new NCursesException(msg));
166 }
167
168 void
169 NCursesWindow::initialize()
170 {
171     if (!b_initialized) {
172         ::initscr();
173         b_initialized = TRUE;
174         if (colorInitialized == COLORS_NEED_INITIALIZATION) {
175             colorInitialized = COLORS_NOT_INITIALIZED;
176             useColors();
177         }
178         ::noecho();
179         ::cbreak();
180     }
181 }
182
183 void
184 NCursesWindow::constructing()
185 {
186     initialize();
187     ++count;
188 }
189
190 NCursesWindow::NCursesWindow()
191   : w(0), alloced(FALSE), par(0), subwins(0), sib(0)
192 {
193     constructing();
194
195     w = static_cast<WINDOW *>(0);
196 }
197
198 NCursesWindow::NCursesWindow(int nlines, int ncols, int begin_y, int begin_x)
199   : w(0), alloced(TRUE), par(0), subwins(0), sib(0)
200 {
201     constructing();
202
203     w = ::newwin(nlines, ncols, begin_y, begin_x);
204     if (w == 0) {
205         err_handler("Cannot construct window");
206     }
207     set_keyboard();
208 }
209
210 NCursesWindow::NCursesWindow(WINDOW* window)
211   : w(0), alloced(FALSE), par(0), subwins(0), sib(0)
212 {
213     constructing();
214
215     // We used to use a reference on the "window" parameter, but we cannot do
216     // that with an opaque pointer (see NCURSES_OPAQUE).  If the parameter was
217     // "::stdscr", that is first set via the "constructing() call, and is null
218     // up to that point.  So we allow a null pointer here as meaning the "same"
219     // as "::stdscr".
220     w = window ? window : ::stdscr;
221     set_keyboard();
222 }
223
224 NCursesWindow::NCursesWindow(NCursesWindow& win, int ny, int nx,
225                              int begin_y, int begin_x, char absrel)
226   : w(0), alloced(TRUE), par(0), subwins(0), sib(0)
227 {
228     constructing();
229     if (absrel == 'a') {        // absolute origin
230         begin_y -= win.begy();
231         begin_x -= win.begx();
232     }
233
234     // Link this window into its parent's list of subwindows.
235     // We use derwin(), since this also works for pads.
236     w = ::derwin(win.w, ny, nx, begin_y, begin_x);
237     if (w == 0) {
238         err_handler("Cannot construct subwindow");
239     }
240
241     par = &win;
242     sib = win.subwins;
243     win.subwins = this;
244 }
245
246 NCursesWindow::NCursesWindow(NCursesWindow& win,
247                                 bool do_box NCURSES_PARAM_INIT(TRUE))
248   : w(0), alloced(TRUE), par(0), subwins(0), sib(0)
249 {
250     constructing();
251     int myHeight = win.height();
252     int myWidth  = win.width();
253     w = :: derwin(win.w, myHeight - 2, myWidth - 2, 1, 1);
254     if (w == 0) {
255         err_handler("Cannot construct subwindow");
256     }
257
258     par = &win;
259     sib = win.subwins;
260     win.subwins = this;
261     subwins = 0;
262
263     if (do_box) {
264         win.box();
265         win.touchwin();
266     }
267 }
268
269 NCursesWindow NCursesWindow::Clone()
270 {
271     WINDOW *d = ::dupwin(w);
272     NCursesWindow W(d);
273     W.subwins = subwins;
274     W.sib = sib;
275     W.par = par;
276     W.alloced = alloced;
277     return W;
278 }
279
280 typedef int (*RIPOFFINIT)(NCursesWindow&);
281 static RIPOFFINIT R_INIT[5];       // There can't be more
282 static int r_init_idx   = 0;
283 static RIPOFFINIT* prip = R_INIT;
284
285 NCursesWindow::NCursesWindow(WINDOW *win, int ncols)
286   : w(0), alloced(FALSE), par(0), subwins(0), sib(0)
287 {
288     (void) ncols;
289     initialize();
290     w = win;
291 }
292
293 int _nc_xx_ripoff_init(WINDOW *w, int ncols)
294 {
295     (void) ncols;
296     int res = ERR;
297
298     RIPOFFINIT init = *prip++;
299     if (init) {
300         res = init(*(new NCursesWindow(w,ncols)));
301     }
302     return res;
303 }
304
305 int NCursesWindow::ripoffline(int ripoff_lines,
306                               int (*init)(NCursesWindow& win))
307 {
308     int code = ::_nc_ripoffline(ripoff_lines,_nc_xx_ripoff_init);
309     if (code == OK && init && ripoff_lines) {
310         R_INIT[r_init_idx++] = init;
311     }
312     return code;
313 }
314
315 bool
316 NCursesWindow::isDescendant(NCursesWindow& win)
317 {
318     bool result = FALSE;
319
320     for (NCursesWindow* p = subwins; p != NULL; p = p->sib) {
321         if (p == &win || p->isDescendant(win)) {
322             result = TRUE;
323             break;
324         }
325     }
326     return result;
327 }
328
329 void
330 NCursesWindow::kill_subwindows()
331 {
332     NCursesWindow* p = subwins;
333
334     subwins = 0;
335     while (p != 0) {
336         NCursesWindow* q = p->sib;
337         p->kill_subwindows();
338         if (p->alloced) {
339             if (p->w != 0)
340                 ::delwin(p->w);
341         }
342         delete p;
343         p = q;
344     }
345 }
346
347
348 NCursesWindow::~NCursesWindow() THROWS(NCursesException)
349 {
350     kill_subwindows();
351
352     if (par != 0) {
353         // Remove this window from the parent's list of subwindows.
354         NCursesWindow * next = par->subwins;
355         NCursesWindow * prev = 0;
356         while (next != 0) {
357             if (next == this) {
358                 if (prev != 0) {
359                     prev->sib = next->sib;
360                 } else {
361                     par->subwins = next->sib;
362                 }
363                 break;
364             }
365             prev = next;
366             next = next->sib;
367         }
368     }
369
370     if (alloced && w != 0)
371         ::delwin(w);
372
373     if (alloced) {
374         --count;
375         if (count == 0) {
376             ::endwin();
377         } else if (count < 0) { // cannot happen!
378             err_handler("Too many windows destroyed");
379         }
380     }
381 }
382
383 // ---------------------------------------------------------------------
384 // Color stuff
385 //
386 int NCursesWindow::colorInitialized = COLORS_NOT_INITIALIZED;
387
388 void
389 NCursesWindow::useColors(void)
390 {
391     if (colorInitialized == COLORS_NOT_INITIALIZED) {
392         if (b_initialized) {
393             if (::has_colors()) {
394                 ::start_color();
395                 colorInitialized = COLORS_ARE_REALLY_THERE;
396             } else {
397                 colorInitialized = COLORS_MONOCHROME;
398             }
399         } else {
400             colorInitialized = COLORS_NEED_INITIALIZATION;
401         }
402     }
403 }
404
405 NCURSES_PAIRS_T
406 NCursesWindow::getPair() const
407 {
408     return static_cast<NCURSES_PAIRS_T>(PAIR_NUMBER(getattrs(w)));
409 }
410
411 NCURSES_COLOR_T
412 NCursesWindow::getcolor(int getback) const
413 {
414     NCURSES_COLOR_T fore, back;
415
416     if (HaveColors()) {
417         if (::pair_content(getPair(), &fore, &back) == ERR)
418             err_handler("Can't get color pair");
419     } else {
420         // Monochrome means white on black
421         back = COLOR_BLACK;
422         fore = COLOR_WHITE;
423     }
424     return getback ? back : fore;
425 }
426
427 int NCursesWindow::NumberOfColors()
428 {
429     return (HaveColors()) ? COLORS : 1;
430 }
431
432 NCURSES_PAIRS_T
433 NCursesWindow::getcolor() const
434 {
435     return (HaveColors()) ? getPair() : 0;
436 }
437
438 int
439 NCursesWindow::setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back, NCURSES_PAIRS_T pair)
440 {
441     return (HaveColors()) ? ::init_pair(pair, fore, back) : OK;
442 }
443
444 int
445 NCursesWindow::setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back)
446 {
447     return setpalette(fore, back, getPair());
448 }
449
450
451 int
452 NCursesWindow::setcolor(NCURSES_PAIRS_T pair)
453 {
454     if (HaveColors()) {
455         if ((pair < 1) || (pair > COLOR_PAIRS))
456             err_handler("Can't set color pair");
457
458         attroff(A_COLOR);
459         attrset(COLOR_PAIR(pair));
460     }
461     return OK;
462 }
463
464 #if HAVE_HAS_KEY
465 bool NCursesWindow::has_mouse() const
466 {
467     return ((::has_key(KEY_MOUSE) || ::has_mouse())
468              ? TRUE : FALSE);
469 }
470 #endif