← Back to branch summary

~ubuntu-branches/ubuntu/precise/ncurses/precise

« back to all changes in this revision

Viewing changes to c++/cursesw.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott James Remnant
  • Date: 2008-11-11 16:40:32 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20081111164032-dudxd0hy2im0f2bj
Tags: 5.7-2ubuntu1
* Merge from debian unstable, remaining changes:
  - On amd64, use /{,usr/}lib32 instead of /emul/ia32-linux/.
  - Link using -Bsymbolic-functions.
  - Don't install the upstream changelog in the runtime library packages.

* Install wide-character patches into /{,usr/}lib32 as well.

Show diffs side-by-side

added added

removed removed

Lines of Context:
c++/cursesw.h
1
1
// * This makes emacs happy -*-Mode: C++;-*-
 
2
// vile:cppmode
2
3
/****************************************************************************
3
 
 * Copyright (c) 1998-2005,2007 Free Software Foundation, Inc.              *
 
4
 * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
4
5
 *                                                                          *
5
6
 * Permission is hereby granted, free of charge, to any person obtaining a  *
6
7
 * copy of this software and associated documentation files (the            *
30
31
#ifndef NCURSES_CURSESW_H_incl
31
32
#define NCURSES_CURSESW_H_incl 1
32
33
 
33
 
// $Id: cursesw.h,v 1.46 2007/11/24 19:09:09 tom Exp $
 
34
// $Id: cursesw.h,v 1.48 2008/01/19 21:09:10 tom Exp $
34
35
 
35
36
#include <etip.h>
36
37
 
54
55
#define addch UNDEF(addch)
55
56
#endif
56
57
 
57
 
#ifdef echochar
58
 
inline int UNDEF(echochar)(chtype ch)  { return echochar(ch); }
59
 
#undef echochar
60
 
#define echochar UNDEF(echochar)
 
58
#ifdef addchstr
 
59
inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); }
 
60
#undef addchstr
 
61
#define addchstr UNDEF(addchstr)
61
62
#endif
62
63
 
63
 
#ifdef insdelln
64
 
inline int UNDEF(insdelln)(int n)  { return insdelln(n); }
65
 
#undef insdelln
66
 
#define insdelln UNDEF(insdelln)
 
64
#ifdef addnstr
 
65
inline int UNDEF(addnstr)(const char *str, int n)
 
66
{ return addnstr(str, n); }
 
67
#undef addnstr
 
68
#define addnstr UNDEF(addnstr)
67
69
#endif
68
70
 
69
71
#ifdef addstr
72
74
#define addstr UNDEF(addstr)
73
75
#endif
74
76
 
 
77
#ifdef attroff
 
78
inline int UNDEF(attroff)(chtype at) { return attroff(at); }
 
79
#undef attroff
 
80
#define attroff UNDEF(attroff)
 
81
#endif
 
82
 
75
83
#ifdef attron
76
84
inline int UNDEF(attron)(chtype at) { return attron(at); }
77
85
#undef attron
78
86
#define attron UNDEF(attron)
79
87
#endif
80
88
 
81
 
#ifdef attroff
82
 
inline int UNDEF(attroff)(chtype at) { return attroff(at); }
83
 
#undef attroff
84
 
#define attroff UNDEF(attroff)
85
 
#endif
86
 
 
87
89
#ifdef attrset
88
90
inline chtype UNDEF(attrset)(chtype at) { return attrset(at); }
89
91
#undef attrset
90
92
#define attrset UNDEF(attrset)
91
93
#endif
92
94
 
93
 
#ifdef color_set
94
 
inline chtype UNDEF(color_set)(short p, void* opts) { return color_set(p, opts); }
95
 
#undef color_set
96
 
#define color_set UNDEF(color_set)
 
95
#ifdef bkgd
 
96
inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }
 
97
#undef bkgd
 
98
#define bkgd UNDEF(bkgd)
 
99
#endif
 
100
 
 
101
#ifdef bkgdset
 
102
inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }
 
103
#undef bkgdset
 
104
#define bkgdset UNDEF(bkgdset)
97
105
#endif
98
106
 
99
107
#ifdef border
109
117
#define box UNDEF(box)
110
118
#endif
111
119
 
112
 
#ifdef mvwhline
113
 
inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {
114
 
  return mvwhline(win, y, x, c, n); }
115
 
#undef mvwhline
116
 
#define mvwhline UNDEF(mvwhline)
117
 
#endif
118
 
 
119
 
#ifdef mvwvline
120
 
inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
121
 
  return mvwvline(win, y, x, c, n); }
122
 
#undef mvwvline
123
 
#define mvwvline UNDEF(mvwvline)
 
120
#ifdef chgat
 
121
inline int UNDEF(chgat)(int n, attr_t attr, short color, const void *opts) {
 
122
  return chgat(n, attr, color, opts); }
 
123
#undef chgat
 
124
#define chgat UNDEF(chgat)
124
125
#endif
125
126
 
126
127
#ifdef clear
149
150
#define clrtoeol UNDEF(clrtoeol)
150
151
#endif
151
152
 
 
153
#ifdef color_set
 
154
inline chtype UNDEF(color_set)(short p, void* opts) { return color_set(p, opts); }
 
155
#undef color_set
 
156
#define color_set UNDEF(color_set)
 
157
#endif
 
158
 
 
159
#ifdef crmode
 
160
inline int UNDEF(crmode)(void) { return crmode(); }
 
161
#undef crmode
 
162
#define crmode UNDEF(crmode)
 
163
#endif
 
164
 
152
165
#ifdef delch
153
166
inline int UNDEF(delch)()  { return delch(); }
154
167
#undef delch
161
174
#define deleteln UNDEF(deleteln)
162
175
#endif
163
176
 
 
177
#ifdef echochar
 
178
inline int UNDEF(echochar)(chtype ch)  { return echochar(ch); }
 
179
#undef echochar
 
180
#define echochar UNDEF(echochar)
 
181
#endif
 
182
 
164
183
#ifdef erase
165
184
inline int UNDEF(erase)()  { return erase(); }
166
185
#undef erase
167
186
#define erase UNDEF(erase)
168
187
#endif
169
188
 
 
189
#ifdef fixterm
 
190
inline int UNDEF(fixterm)(void) { return fixterm(); }
 
191
#undef fixterm
 
192
#define fixterm UNDEF(fixterm)
 
193
#endif
 
194
 
170
195
#ifdef flushok
171
196
inline int UNDEF(flushok)(WINDOW* _win, bool _bf)  {
172
197
  return flushok(_win, _bf); }
176
201
#define _no_flushok
177
202
#endif
178
203
 
 
204
#ifdef getattrs
 
205
inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); }
 
206
#undef getattrs
 
207
#define getattrs UNDEF(getattrs)
 
208
#endif
 
209
 
 
210
#ifdef getbegyx
 
211
inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y, x); }
 
212
#undef getbegyx
 
213
#define getbegyx UNDEF(getbegyx)
 
214
#endif
 
215
 
 
216
#ifdef getbkgd
 
217
inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }
 
218
#undef getbkgd
 
219
#define getbkgd UNDEF(getbkgd)
 
220
#endif
 
221
 
179
222
#ifdef getch
180
223
inline int UNDEF(getch)()  { return getch(); }
181
224
#undef getch
182
225
#define getch UNDEF(getch)
183
226
#endif
184
227
 
 
228
#ifdef getmaxyx
 
229
inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y, x); }
 
230
#undef getmaxyx
 
231
#define getmaxyx UNDEF(getmaxyx)
 
232
#endif
 
233
 
 
234
#ifdef getnstr
 
235
inline int UNDEF(getnstr)(char *_str, int n)  { return getnstr(_str, n); }
 
236
#undef getnstr
 
237
#define getnstr UNDEF(getnstr)
 
238
#endif
 
239
 
 
240
#ifdef getparyx
 
241
inline void UNDEF(getparyx)(WINDOW* win, int& y, int& x) { getparyx(win, y, x); }
 
242
#undef getparyx
 
243
#define getparyx UNDEF(getparyx)
 
244
#endif
 
245
 
185
246
#ifdef getstr
186
247
inline int UNDEF(getstr)(char *_str)  { return getstr(_str); }
187
248
#undef getstr
188
249
#define getstr UNDEF(getstr)
189
250
#endif
190
251
 
191
 
#ifdef instr
192
 
inline int UNDEF(instr)(char *_str)  { return instr(_str); }
193
 
#undef instr
194
 
#define instr UNDEF(instr)
195
 
#endif
196
 
 
197
 
#ifdef innstr
198
 
inline int UNDEF(innstr)(char *_str, int n)  { return innstr(_str, n); }
199
 
#undef innstr
200
 
#define innstr UNDEF(innstr)
201
 
#endif
202
 
 
203
 
#ifdef mvwinnstr
204
 
inline int UNDEF(mvwinnstr)(WINDOW *win, int y, int x, char *_str, int n) {
205
 
  return mvwinnstr(win, y, x, _str, n); }
206
 
#undef mvwinnstr
207
 
#define mvwinnstr UNDEF(mvwinnstr)
208
 
#endif
209
 
 
210
 
#ifdef mvinnstr
211
 
inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
212
 
  return mvinnstr(y, x, _str, n); }
213
 
#undef mvinnstr
214
 
#define mvinnstr UNDEF(mvinnstr)
215
 
#endif
216
 
 
217
 
#ifdef winsstr
218
 
inline int UNDEF(winsstr)(WINDOW *w, const char *_str)  {
219
 
  return winsstr(w, _str); }
220
 
#undef winsstr
221
 
#define winsstr UNDEF(winsstr)
222
 
#endif
223
 
 
224
 
#ifdef mvwinsstr
225
 
inline int UNDEF(mvwinsstr)(WINDOW *w, int y, int x,  const char *_str)  {
226
 
  return mvwinsstr(w, y, x, _str); }
227
 
#undef mvwinsstr
228
 
#define mvwinsstr UNDEF(mvwinsstr)
229
 
#endif
230
 
 
231
 
#ifdef insstr
232
 
inline int UNDEF(insstr)(const char *_str)  {
233
 
  return insstr(_str); }
234
 
#undef insstr
235
 
#define insstr UNDEF(insstr)
236
 
#endif
237
 
 
238
 
#ifdef mvinsstr
239
 
inline int UNDEF(mvinsstr)(int y, int x, const char *_str)  {
240
 
  return mvinsstr(y, x, _str); }
241
 
#undef mvinsstr
242
 
#define mvinsstr UNDEF(mvinsstr)
243
 
#endif
244
 
 
245
 
#ifdef insnstr
246
 
inline int UNDEF(insnstr)(const char *_str, int n)  {
247
 
  return insnstr(_str, n); }
248
 
#undef insnstr
249
 
#define insnstr UNDEF(insnstr)
250
 
#endif
251
 
 
252
 
#ifdef mvwinsnstr
253
 
inline int UNDEF(mvwinsnstr)(WINDOW *w, int y, int x, const char *_str, int n) {
254
 
  return mvwinsnstr(w, y, x, _str, n); }
255
 
#undef mvwinsnstr
256
 
#define mvwinsnstr UNDEF(mvwinsnstr)
257
 
#endif
258
 
 
259
 
#ifdef mvinsnstr
260
 
inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {
261
 
  return mvinsnstr(y, x, _str, n); }
262
 
#undef mvinsnstr
263
 
#define mvinsnstr UNDEF(mvinsnstr)
264
 
#endif
265
 
 
266
 
#ifdef getnstr
267
 
inline int UNDEF(getnstr)(char *_str, int n)  { return getnstr(_str, n); }
268
 
#undef getnstr
269
 
#define getnstr UNDEF(getnstr)
270
 
#endif
271
 
 
272
252
#ifdef getyx
273
253
inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) {
274
254
  getyx(win, y, x); }
276
256
#define getyx UNDEF(getyx)
277
257
#endif
278
258
 
279
 
#ifdef getbegyx
280
 
inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y, x); }
281
 
#undef getbegyx
282
 
#define getbegyx UNDEF(getbegyx)
283
 
#endif
284
 
 
285
 
#ifdef getmaxyx
286
 
inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y, x); }
287
 
#undef getmaxyx
288
 
#define getmaxyx UNDEF(getmaxyx)
289
 
#endif
290
 
 
291
259
#ifdef hline
292
260
inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); }
293
261
#undef hline
300
268
#define inch UNDEF(inch)
301
269
#endif
302
270
 
 
271
#ifdef inchstr
 
272
inline int UNDEF(inchstr)(chtype *str)  { return inchstr(str); }
 
273
#undef inchstr
 
274
#define inchstr UNDEF(inchstr)
 
275
#endif
 
276
 
 
277
#ifdef innstr
 
278
inline int UNDEF(innstr)(char *_str, int n)  { return innstr(_str, n); }
 
279
#undef innstr
 
280
#define innstr UNDEF(innstr)
 
281
#endif
 
282
 
303
283
#ifdef insch
304
284
inline int UNDEF(insch)(chtype c)  { return insch(c); }
305
285
#undef insch
306
286
#define insch UNDEF(insch)
307
287
#endif
308
288
 
 
289
#ifdef insdelln
 
290
inline int UNDEF(insdelln)(int n)  { return insdelln(n); }
 
291
#undef insdelln
 
292
#define insdelln UNDEF(insdelln)
 
293
#endif
 
294
 
309
295
#ifdef insertln
310
296
inline int UNDEF(insertln)()  { return insertln(); }
311
297
#undef insertln
312
298
#define insertln UNDEF(insertln)
313
299
#endif
314
300
 
 
301
#ifdef insnstr
 
302
inline int UNDEF(insnstr)(const char *_str, int n)  {
 
303
  return insnstr(_str, n); }
 
304
#undef insnstr
 
305
#define insnstr UNDEF(insnstr)
 
306
#endif
 
307
 
 
308
#ifdef insstr
 
309
inline int UNDEF(insstr)(const char *_str)  {
 
310
  return insstr(_str); }
 
311
#undef insstr
 
312
#define insstr UNDEF(insstr)
 
313
#endif
 
314
 
 
315
#ifdef instr
 
316
inline int UNDEF(instr)(char *_str)  { return instr(_str); }
 
317
#undef instr
 
318
#define instr UNDEF(instr)
 
319
#endif
 
320
 
 
321
#ifdef intrflush
 
322
inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); }
 
323
#undef intrflush
 
324
#define intrflush UNDEF(intrflush)
 
325
#endif
 
326
 
315
327
#ifdef leaveok
316
328
inline int UNDEF(leaveok)(WINDOW* win, bool bf)  { return leaveok(win, bf); }
317
329
#undef leaveok
326
338
#define move UNDEF(move)
327
339
#endif
328
340
 
 
341
#ifdef mvaddch
 
342
inline int UNDEF(mvaddch)(int y, int x, chtype ch)
 
343
{ return mvaddch(y, x, ch); }
 
344
#undef mvaddch
 
345
#define mvaddch UNDEF(mvaddch)
 
346
#endif
 
347
 
 
348
#ifdef mvaddnstr
 
349
inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)
 
350
{ return mvaddnstr(y, x, str, n); }
 
351
#undef mvaddnstr
 
352
#define mvaddnstr UNDEF(mvaddnstr)
 
353
#endif
 
354
 
 
355
#ifdef mvaddstr
 
356
inline int UNDEF(mvaddstr)(int y, int x, const char * str)
 
357
{ return mvaddstr(y, x, str); }
 
358
#undef mvaddstr
 
359
#define mvaddstr UNDEF(mvaddstr)
 
360
#endif
 
361
 
 
362
#ifdef mvchgat
 
363
inline int UNDEF(mvchgat)(int y, int x, int n,
 
364
                          attr_t attr, short color, const void *opts) {
 
365
  return mvchgat(y, x, n, attr, color, opts); }
 
366
#undef mvchgat
 
367
#define mvchgat UNDEF(mvchgat)
 
368
#endif
 
369
 
 
370
#ifdef mvdelch
 
371
inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}
 
372
#undef mvdelch
 
373
#define mvdelch UNDEF(mvdelch)
 
374
#endif
 
375
 
 
376
#ifdef mvgetch
 
377
inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}
 
378
#undef mvgetch
 
379
#define mvgetch UNDEF(mvgetch)
 
380
#endif
 
381
 
 
382
#ifdef mvgetnstr
 
383
inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {
 
384
  return mvgetnstr(y, x, str, n);}
 
385
#undef mvgetnstr
 
386
#define mvgetnstr UNDEF(mvgetnstr)
 
387
#endif
 
388
 
 
389
#ifdef mvgetstr
 
390
inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
 
391
#undef mvgetstr
 
392
#define mvgetstr UNDEF(mvgetstr)
 
393
#endif
 
394
 
 
395
#ifdef mvinch
 
396
inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}
 
397
#undef mvinch
 
398
#define mvinch UNDEF(mvinch)
 
399
#endif
 
400
 
 
401
#ifdef mvinnstr
 
402
inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
 
403
  return mvinnstr(y, x, _str, n); }
 
404
#undef mvinnstr
 
405
#define mvinnstr UNDEF(mvinnstr)
 
406
#endif
 
407
 
 
408
#ifdef mvinsch
 
409
inline int UNDEF(mvinsch)(int y, int x, chtype c)
 
410
{ return mvinsch(y, x, c); }
 
411
#undef mvinsch
 
412
#define mvinsch UNDEF(mvinsch)
 
413
#endif
 
414
 
 
415
#ifdef mvinsnstr
 
416
inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {
 
417
  return mvinsnstr(y, x, _str, n); }
 
418
#undef mvinsnstr
 
419
#define mvinsnstr UNDEF(mvinsnstr)
 
420
#endif
 
421
 
 
422
#ifdef mvinsstr
 
423
inline int UNDEF(mvinsstr)(int y, int x, const char *_str)  {
 
424
  return mvinsstr(y, x, _str); }
 
425
#undef mvinsstr
 
426
#define mvinsstr UNDEF(mvinsstr)
 
427
#endif
 
428
 
 
429
#ifdef mvwaddch
 
430
inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)
 
431
{ return mvwaddch(win, y, x, ch); }
 
432
#undef mvwaddch
 
433
#define mvwaddch UNDEF(mvwaddch)
 
434
#endif
 
435
 
 
436
#ifdef mvwaddchnstr
 
437
inline int UNDEF(mvwaddchnstr)(WINDOW *win, int y, int x, const chtype *str, int n)
 
438
{ return mvwaddchnstr(win, y, x, str, n); }
 
439
#undef mvwaddchnstr
 
440
#define mvwaddchnstr UNDEF(mvwaddchnstr)
 
441
#endif
 
442
 
 
443
#ifdef mvwaddchstr
 
444
inline int UNDEF(mvwaddchstr)(WINDOW *win, int y, int x, const chtype *str)
 
445
{ return mvwaddchstr(win, y, x, str); }
 
446
#undef mvwaddchstr
 
447
#define mvwaddchstr UNDEF(mvwaddchstr)
 
448
#endif
 
449
 
 
450
#ifdef mvwaddnstr
 
451
inline int UNDEF(mvwaddnstr)(WINDOW *win, int y, int x, const char *str, int n)
 
452
{ return mvwaddnstr(win, y, x, str, n); }
 
453
#undef mvwaddnstr
 
454
#define mvwaddnstr UNDEF(mvwaddnstr)
 
455
#endif
 
456
 
 
457
#ifdef mvwaddstr
 
458
inline int UNDEF(mvwaddstr)(WINDOW *win, int y, int x, const char * str)
 
459
{ return mvwaddstr(win, y, x, str); }
 
460
#undef mvwaddstr
 
461
#define mvwaddstr UNDEF(mvwaddstr)
 
462
#endif
 
463
 
 
464
#ifdef mvwchgat
 
465
inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,
 
466
                           attr_t attr, short color, const void *opts) {
 
467
  return mvwchgat(win, y, x, n, attr, color, opts); }
 
468
#undef mvwchgat
 
469
#define mvwchgat UNDEF(mvwchgat)
 
470
#endif
 
471
 
 
472
#ifdef mvwdelch
 
473
inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)
 
474
{ return mvwdelch(win, y, x); }
 
475
#undef mvwdelch
 
476
#define mvwdelch UNDEF(mvwdelch)
 
477
#endif
 
478
 
 
479
#ifdef mvwgetch
 
480
inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
 
481
#undef mvwgetch
 
482
#define mvwgetch UNDEF(mvwgetch)
 
483
#endif
 
484
 
 
485
#ifdef mvwgetnstr
 
486
inline int UNDEF(mvwgetnstr)(WINDOW *win, int y, int x, char *str, int n)
 
487
{return mvwgetnstr(win, y, x, str, n);}
 
488
#undef mvwgetnstr
 
489
#define mvwgetnstr UNDEF(mvwgetnstr)
 
490
#endif
 
491
 
 
492
#ifdef mvwgetstr
 
493
inline int UNDEF(mvwgetstr)(WINDOW *win, int y, int x, char *str)
 
494
{return mvwgetstr(win, y, x, str);}
 
495
#undef mvwgetstr
 
496
#define mvwgetstr UNDEF(mvwgetstr)
 
497
#endif
 
498
 
 
499
#ifdef mvwhline
 
500
inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {
 
501
  return mvwhline(win, y, x, c, n); }
 
502
#undef mvwhline
 
503
#define mvwhline UNDEF(mvwhline)
 
504
#endif
 
505
 
 
506
#ifdef mvwinch
 
507
inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {
 
508
  return mvwinch(win, y, x);}
 
509
#undef mvwinch
 
510
#define mvwinch UNDEF(mvwinch)
 
511
#endif
 
512
 
 
513
#ifdef mvwinchnstr
 
514
inline int UNDEF(mvwinchnstr)(WINDOW *win, int y, int x, chtype *str, int n)  { return mvwinchnstr(win, y, x, str, n); }
 
515
#undef mvwinchnstr
 
516
#define mvwinchnstr UNDEF(mvwinchnstr)
 
517
#endif
 
518
 
 
519
#ifdef mvwinchstr
 
520
inline int UNDEF(mvwinchstr)(WINDOW *win, int y, int x, chtype *str)  { return mvwinchstr(win, y, x, str); }
 
521
#undef mvwinchstr
 
522
#define mvwinchstr UNDEF(mvwinchstr)
 
523
#endif
 
524
 
 
525
#ifdef mvwinnstr
 
526
inline int UNDEF(mvwinnstr)(WINDOW *win, int y, int x, char *_str, int n) {
 
527
  return mvwinnstr(win, y, x, _str, n); }
 
528
#undef mvwinnstr
 
529
#define mvwinnstr UNDEF(mvwinnstr)
 
530
#endif
 
531
 
 
532
#ifdef mvwinsch
 
533
inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)
 
534
{ return mvwinsch(win, y, x, c); }
 
535
#undef mvwinsch
 
536
#define mvwinsch UNDEF(mvwinsch)
 
537
#endif
 
538
 
 
539
#ifdef mvwinsnstr
 
540
inline int UNDEF(mvwinsnstr)(WINDOW *w, int y, int x, const char *_str, int n) {
 
541
  return mvwinsnstr(w, y, x, _str, n); }
 
542
#undef mvwinsnstr
 
543
#define mvwinsnstr UNDEF(mvwinsnstr)
 
544
#endif
 
545
 
 
546
#ifdef mvwinsstr
 
547
inline int UNDEF(mvwinsstr)(WINDOW *w, int y, int x,  const char *_str)  {
 
548
  return mvwinsstr(w, y, x, _str); }
 
549
#undef mvwinsstr
 
550
#define mvwinsstr UNDEF(mvwinsstr)
 
551
#endif
 
552
 
 
553
#ifdef mvwvline
 
554
inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
 
555
  return mvwvline(win, y, x, c, n); }
 
556
#undef mvwvline
 
557
#define mvwvline UNDEF(mvwvline)
 
558
#endif
 
559
 
 
560
#ifdef napms
 
561
inline void UNDEF(napms)(unsigned long x) { napms(x); }
 
562
#undef napms
 
563
#define napms UNDEF(napms)
 
564
#endif
 
565
 
 
566
#ifdef nocrmode
 
567
inline int UNDEF(nocrmode)(void) { return nocrmode(); }
 
568
#undef nocrmode
 
569
#define nocrmode UNDEF(nocrmode)
 
570
#endif
 
571
 
 
572
#ifdef nodelay
 
573
inline void UNDEF(nodelay)() { nodelay(); }
 
574
#undef nodelay
 
575
#define nodelay UNDEF(nodelay)
 
576
#endif
 
577
 
 
578
#ifdef redrawwin
 
579
inline int UNDEF(redrawwin)(WINDOW *win)  { return redrawwin(win); }
 
580
#undef redrawwin
 
581
#define redrawwin UNDEF(redrawwin)
 
582
#endif
 
583
 
329
584
#ifdef refresh
330
585
inline int UNDEF(refresh)()  { return refresh(); }
331
586
#undef refresh
332
587
#define refresh UNDEF(refresh)
333
588
#endif
334
589
 
335
 
#ifdef redrawwin
336
 
inline int UNDEF(redrawwin)(WINDOW *win)  { return redrawwin(win); }
337
 
#undef redrawwin
338
 
#define redrawwin UNDEF(redrawwin)
 
590
#ifdef resetterm
 
591
inline int UNDEF(resetterm)(void) { return resetterm(); }
 
592
#undef resetterm
 
593
#define resetterm UNDEF(resetterm)
 
594
#endif
 
595
 
 
596
#ifdef saveterm
 
597
inline int UNDEF(saveterm)(void) { return saveterm(); }
 
598
#undef saveterm
 
599
#define saveterm UNDEF(saveterm)
339
600
#endif
340
601
 
341
602
#ifdef scrl
418
679
#define vline UNDEF(vline)
419
680
#endif
420
681
 
 
682
#ifdef waddchstr
 
683
inline int UNDEF(waddchstr)(WINDOW *win, chtype *at) { return waddchstr(win, at); }
 
684
#undef waddchstr
 
685
#define waddchstr UNDEF(waddchstr)
 
686
#endif
 
687
 
421
688
#ifdef waddstr
422
689
inline int UNDEF(waddstr)(WINDOW *win, char *str) { return waddstr(win, str); }
423
690
#undef waddstr
424
691
#define waddstr UNDEF(waddstr)
425
692
#endif
426
693
 
427
 
#ifdef waddchstr
428
 
inline int UNDEF(waddchstr)(WINDOW *win, chtype *at) { return waddchstr(win, at); }
429
 
#undef waddchstr
430
 
#define waddchstr UNDEF(waddchstr)
431
 
#endif
432
 
 
433
 
#ifdef wstandend
434
 
inline int UNDEF(wstandend)(WINDOW *win)  { return wstandend(win); }
435
 
#undef wstandend
436
 
#define wstandend UNDEF(wstandend)
437
 
#endif
438
 
 
439
 
#ifdef wstandout
440
 
inline int UNDEF(wstandout)(WINDOW *win)  { return wstandout(win); }
441
 
#undef wstandout
442
 
#define wstandout UNDEF(wstandout)
443
 
#endif
444
 
 
445
 
 
446
694
#ifdef wattroff
447
695
inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att); }
448
696
#undef wattroff
449
697
#define wattroff UNDEF(wattroff)
450
698
#endif
451
699
 
452
 
#ifdef chgat
453
 
inline int UNDEF(chgat)(int n, attr_t attr, short color, const void *opts) {
454
 
  return chgat(n, attr, color, opts); }
455
 
#undef chgat
456
 
#define chgat UNDEF(chgat)
457
 
#endif
458
 
 
459
 
#ifdef mvchgat
460
 
inline int UNDEF(mvchgat)(int y, int x, int n,
461
 
                          attr_t attr, short color, const void *opts) {
462
 
  return mvchgat(y, x, n, attr, color, opts); }
463
 
#undef mvchgat
464
 
#define mvchgat UNDEF(mvchgat)
465
 
#endif
466
 
 
467
 
#ifdef mvwchgat
468
 
inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,
469
 
                           attr_t attr, short color, const void *opts) {
470
 
  return mvwchgat(win, y, x, n, attr, color, opts); }
471
 
#undef mvwchgat
472
 
#define mvwchgat UNDEF(mvwchgat)
473
 
#endif
474
 
 
475
700
#ifdef wattrset
476
701
inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att); }
477
702
#undef wattrset
484
709
#define winch UNDEF(winch)
485
710
#endif
486
711
 
487
 
#ifdef mvwaddch
488
 
inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)
489
 
{ return mvwaddch(win, y, x, ch); }
490
 
#undef mvwaddch
491
 
#define mvwaddch UNDEF(mvwaddch)
492
 
#endif
493
 
 
494
 
#ifdef mvwaddchnstr
495
 
inline int UNDEF(mvwaddchnstr)(WINDOW *win, int y, int x, chtype *str, int n)
496
 
{ return mvwaddchnstr(win, y, x, str, n); }
497
 
#undef mvwaddchnstr
498
 
#define mvwaddchnstr UNDEF(mvwaddchnstr)
499
 
#endif
500
 
 
501
 
#ifdef mvwaddchstr
502
 
inline int UNDEF(mvwaddchstr)(WINDOW *win, int y, int x, chtype *str)
503
 
{ return mvwaddchstr(win, y, x, str); }
504
 
#undef mvwaddchstr
505
 
#define mvwaddchstr UNDEF(mvwaddchstr)
506
 
#endif
507
 
 
508
 
#ifdef addnstr
509
 
inline int UNDEF(addnstr)(const char *str, int n)
510
 
{ return addnstr(str, n); }
511
 
#undef addnstr
512
 
#define addnstr UNDEF(addnstr)
513
 
#endif
514
 
 
515
 
#ifdef mvwaddnstr
516
 
inline int UNDEF(mvwaddnstr)(WINDOW *win, int y, int x, const char *str, int n)
517
 
{ return mvwaddnstr(win, y, x, str, n); }
518
 
#undef mvwaddnstr
519
 
#define mvwaddnstr UNDEF(mvwaddnstr)
520
 
#endif
521
 
 
522
 
#ifdef mvwaddstr
523
 
inline int UNDEF(mvwaddstr)(WINDOW *win, int y, int x, const char * str)
524
 
{ return mvwaddstr(win, y, x, str); }
525
 
#undef mvwaddstr
526
 
#define mvwaddstr UNDEF(mvwaddstr)
527
 
#endif
528
 
 
529
 
#ifdef mvwdelch
530
 
inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)
531
 
{ return mvwdelch(win, y, x); }
532
 
#undef mvwdelch
533
 
#define mvwdelch UNDEF(mvwdelch)
534
 
#endif
535
 
 
536
 
#ifdef mvwgetch
537
 
inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
538
 
#undef mvwgetch
539
 
#define mvwgetch UNDEF(mvwgetch)
540
 
#endif
541
 
 
542
 
#ifdef mvwgetstr
543
 
inline int UNDEF(mvwgetstr)(WINDOW *win, int y, int x, char *str)
544
 
{return mvwgetstr(win, y, x, str);}
545
 
#undef mvwgetstr
546
 
#define mvwgetstr UNDEF(mvwgetstr)
547
 
#endif
548
 
 
549
 
#ifdef mvwgetnstr
550
 
inline int UNDEF(mvwgetnstr)(WINDOW *win, int y, int x, char *str, int n)
551
 
{return mvwgetnstr(win, y, x, str, n);}
552
 
#undef mvwgetnstr
553
 
#define mvwgetnstr UNDEF(mvwgetnstr)
554
 
#endif
555
 
 
556
 
#ifdef mvwinch
557
 
inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {
558
 
  return mvwinch(win, y, x);}
559
 
#undef mvwinch
560
 
#define mvwinch UNDEF(mvwinch)
561
 
#endif
562
 
 
563
 
#ifdef mvwinsch
564
 
inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)
565
 
{ return mvwinsch(win, y, x, c); }
566
 
#undef mvwinsch
567
 
#define mvwinsch UNDEF(mvwinsch)
568
 
#endif
569
 
 
570
 
#ifdef mvaddch
571
 
inline int UNDEF(mvaddch)(int y, int x, chtype ch)
572
 
{ return mvaddch(y, x, ch); }
573
 
#undef mvaddch
574
 
#define mvaddch UNDEF(mvaddch)
575
 
#endif
576
 
 
577
 
#ifdef mvaddnstr
578
 
inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)
579
 
{ return mvaddnstr(y, x, str, n); }
580
 
#undef mvaddnstr
581
 
#define mvaddnstr UNDEF(mvaddnstr)
582
 
#endif
583
 
 
584
 
#ifdef mvaddstr
585
 
inline int UNDEF(mvaddstr)(int y, int x, const char * str)
586
 
{ return mvaddstr(y, x, str); }
587
 
#undef mvaddstr
588
 
#define mvaddstr UNDEF(mvaddstr)
589
 
#endif
590
 
 
591
 
#ifdef mvdelch
592
 
inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}
593
 
#undef mvdelch
594
 
#define mvdelch UNDEF(mvdelch)
595
 
#endif
596
 
 
597
 
#ifdef mvgetch
598
 
inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}
599
 
#undef mvgetch
600
 
#define mvgetch UNDEF(mvgetch)
601
 
#endif
602
 
 
603
 
#ifdef mvgetstr
604
 
inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
605
 
#undef mvgetstr
606
 
#define mvgetstr UNDEF(mvgetstr)
607
 
#endif
608
 
 
609
 
#ifdef mvgetnstr
610
 
inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {
611
 
  return mvgetnstr(y, x, str, n);}
612
 
#undef mvgetnstr
613
 
#define mvgetnstr UNDEF(mvgetnstr)
614
 
#endif
615
 
 
616
 
#ifdef mvinch
617
 
inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}
618
 
#undef mvinch
619
 
#define mvinch UNDEF(mvinch)
620
 
#endif
621
 
 
622
 
#ifdef mvinsch
623
 
inline int UNDEF(mvinsch)(int y, int x, chtype c)
624
 
{ return mvinsch(y, x, c); }
625
 
#undef mvinsch
626
 
#define mvinsch UNDEF(mvinsch)
627
 
#endif
628
 
 
629
 
#ifdef napms
630
 
inline void UNDEF(napms)(unsigned long x) { napms(x); }
631
 
#undef napms
632
 
#define napms UNDEF(napms)
633
 
#endif
634
 
 
635
 
#ifdef fixterm
636
 
inline int UNDEF(fixterm)(void) { return fixterm(); }
637
 
#undef fixterm
638
 
#define fixterm UNDEF(fixterm)
639
 
#endif
640
 
 
641
 
#ifdef resetterm
642
 
inline int UNDEF(resetterm)(void) { return resetterm(); }
643
 
#undef resetterm
644
 
#define resetterm UNDEF(resetterm)
645
 
#endif
646
 
 
647
 
#ifdef saveterm
648
 
inline int UNDEF(saveterm)(void) { return saveterm(); }
649
 
#undef saveterm
650
 
#define saveterm UNDEF(saveterm)
651
 
#endif
652
 
 
653
 
#ifdef crmode
654
 
inline int UNDEF(crmode)(void) { return crmode(); }
655
 
#undef crmode
656
 
#define crmode UNDEF(crmode)
657
 
#endif
658
 
 
659
 
#ifdef nocrmode
660
 
inline int UNDEF(nocrmode)(void) { return nocrmode(); }
661
 
#undef nocrmode
662
 
#define nocrmode UNDEF(nocrmode)
663
 
#endif
664
 
 
665
 
#ifdef getbkgd
666
 
inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }
667
 
#undef getbkgd
668
 
#define getbkgd UNDEF(getbkgd)
669
 
#endif
670
 
 
671
 
#ifdef bkgd
672
 
inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }
673
 
#undef bkgd
674
 
#define bkgd UNDEF(bkgd)
675
 
#endif
676
 
 
677
 
#ifdef bkgdset
678
 
inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }
679
 
#undef bkgdset
680
 
#define bkgdset UNDEF(bkgdset)
 
712
#ifdef winchnstr
 
713
inline int UNDEF(winchnstr)(WINDOW *win, chtype *str, int n)  { return winchnstr(win, str, n); }
 
714
#undef winchnstr
 
715
#define winchnstr UNDEF(winchnstr)
 
716
#endif
 
717
 
 
718
#ifdef winchstr
 
719
inline int UNDEF(winchstr)(WINDOW *win, chtype *str)  { return winchstr(win, str); }
 
720
#undef winchstr
 
721
#define winchstr UNDEF(winchstr)
 
722
#endif
 
723
 
 
724
#ifdef winsstr
 
725
inline int UNDEF(winsstr)(WINDOW *w, const char *_str)  {
 
726
  return winsstr(w, _str); }
 
727
#undef winsstr
 
728
#define winsstr UNDEF(winsstr)
 
729
#endif
 
730
 
 
731
#ifdef wstandend
 
732
inline int UNDEF(wstandend)(WINDOW *win)  { return wstandend(win); }
 
733
#undef wstandend
 
734
#define wstandend UNDEF(wstandend)
 
735
#endif
 
736
 
 
737
#ifdef wstandout
 
738
inline int UNDEF(wstandout)(WINDOW *win)  { return wstandout(win); }
 
739
#undef wstandout
 
740
#define wstandout UNDEF(wstandout)
681
741
#endif
682
742
 
683
743
/*
824
884
  int            begy() const { return getbegy(w); }
825
885
  // Line of top left corner relative to stdscr
826
886
 
 
887
  int            curx() const { return getcurx(w); }
 
888
  // Column of top left corner relative to stdscr
 
889
 
 
890
  int            cury() const { return getcury(w); }
 
891
  // Line of top left corner relative to stdscr
 
892
 
827
893
  int            maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)-1; }
828
894
  // Largest x coord in window
829
895
 
862
928
  void           getyx(int& y, int& x) const { ::getyx(w, y, x); }
863
929
  // Get current position of the cursor
864
930
 
 
931
  void           getbegyx(int& y, int& x) const { ::getbegyx(w, y, x); }
 
932
  // Get beginning of the window
 
933
 
 
934
  void           getmaxyx(int& y, int& x) const { ::getmaxyx(w, y, x); }
 
935
  // Get size of the window
 
936
 
 
937
  void           getparyx(int& y, int& x) const { ::getparyx(w, y, x); }
 
938
  // Get parent's beginning of the window
 
939
 
865
940
  int            mvcur(int oldrow, int oldcol, int newrow, int newcol) const {
866
941
    return ::mvcur(oldrow, oldcol, newrow, newcol); }
867
942
  // Perform lowlevel cursor motion that takes effect immediately.
904
979
  ;
905
980
#endif
906
981
 
 
982
  int            scanw(const char*, va_list);
 
983
    // Perform a scanw function from the window.
 
984
 
907
985
  int            scanw(int y, int x, const char* fmt, ...)
908
986
    // Move the cursor to the requested position and then perform a scanw
909
987
    // from the window.
913
991
  ;
914
992
#endif
915
993
 
 
994
  int            scanw(int y, int x, const char* fmt, va_list);
 
995
    // Move the cursor to the requested position and then perform a scanw
 
996
    // from the window.
 
997
 
916
998
  // -------------------------------------------------------------------------
917
999
  // output
918
1000
  // -------------------------------------------------------------------------
934
1016
 
935
1017
  int            addstr(int y, int x, const char * str, int n=-1) {
936
1018
    return ::mvwaddnstr(w, y, x, str, n); }
937
 
  // Move the cursor to the requested position and then perform the addstr
 
1019
  // Move the cursor to the requested position and then perform the addchstr
 
1020
  // as described above.
 
1021
 
 
1022
  int            addchstr(const chtype* str, int n=-1) {
 
1023
    return ::waddchnstr(w, str, n); }
 
1024
  // Write the string str to the window, stop writing if the terminating
 
1025
  // NUL or the limit n is reached. If n is negative, it is ignored.
 
1026
 
 
1027
  int            addchstr(int y, int x, const chtype * str, int n=-1) {
 
1028
    return ::mvwaddchnstr(w, y, x, str, n); }
 
1029
  // Move the cursor to the requested position and then perform the addchstr
938
1030
  // as described above.
939
1031
 
940
1032
  int            printw(const char* fmt, ...)
953
1045
  ;
954
1046
#endif
955
1047
 
 
1048
  int            printw(const char* fmt, va_list args);
 
1049
    // Do a formatted print to the window.
 
1050
 
 
1051
  int            printw(int y, int x, const char * fmt, va_list args);
 
1052
    // Move the cursor and then do a formatted print to the window.
 
1053
 
956
1054
  chtype         inch() const { return ::winch(w); }
957
1055
  // Retrieve attributed character under the current cursor position.
958
1056
 
960
1058
  // Move cursor to requested position and then retrieve attributed character
961
1059
  // at this position.
962
1060
 
 
1061
  int            inchstr(chtype* str, int n=-1) {
 
1062
    return ::winchnstr(w, str, n); }
 
1063
  // Read the string str from the window, stop reading if the terminating
 
1064
  // NUL or the limit n is reached. If n is negative, it is ignored.
 
1065
 
 
1066
  int            inchstr(int y, int x, chtype * str, int n=-1) {
 
1067
    return ::mvwinchnstr(w, y, x, str, n); }
 
1068
  // Move the cursor to the requested position and then perform the inchstr
 
1069
  // as described above.
 
1070
 
963
1071
  int            insch(chtype ch) { return ::winsch(w, ch); }
964
1072
  // Insert attributed character into the window before current cursor
965
1073
  // position.
996
1104
  int            attrset(chtype at) { return ::wattrset(w, static_cast<int>(at)); }
997
1105
  // Set the window attributes;
998
1106
 
 
1107
  chtype         attrget() { return ::getattrs(w); }
 
1108
  // Get the window attributes;
 
1109
 
999
1110
  int            color_set(short color_pair_number, void* opts=NULL) {
1000
1111
    return ::wcolor_set(w, color_pair_number, opts); }
1001
1112
  // Set the window color attribute;
1111
1222
  // If bf is TRUE, use insert/delete line hardware support if possible.
1112
1223
  // Otherwise do it in software.
1113
1224
 
1114
 
 
1115
1225
  void           idcok(bool bf) { ::idcok(w, bf); }
1116
1226
  // If bf is TRUE, use insert/delete character hardware support if possible.
1117
1227
  // Otherwise do it in software.
1118
1228
 
 
1229
  int            touchline(int s, int c) { return ::touchline(w, s, c); }
 
1230
  // Mark the given lines as modified.
 
1231
 
1119
1232
  int            touchwin()   { return ::wtouchln(w, 0, height(), 1); }
1120
1233
  // Mark the whole window as modified.
1121
1234
 
1168
1281
  // If called with bf=TRUE, any change in the window will cause an
1169
1282
  // automatic immediate refresh()
1170
1283
 
 
1284
  int            intrflush(bool bf) { return ::intrflush(w, bf); }
 
1285
 
1171
1286
  int            keypad(bool bf) { return ::keypad(w, bf); }
1172
1287
  // If called with bf=TRUE, the application will interpret function keys.
1173
1288
 
 
1289
  int            nodelay(bool bf) { return ::nodelay(w, bf); }
 
1290
 
1174
1291
  int            meta(bool bf) { return ::meta(w, bf); }
1175
1292
  // If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise
1176
1293
  // 7-Bit characters are generated.
1217
1334
  // -------------------------------------------------------------------------
1218
1335
  // Extended functions
1219
1336
  // -------------------------------------------------------------------------
1220
 
#ifdef NCURSES_EXT_FUNCS
 
1337
#if defined(NCURSES_EXT_FUNCS) && (NCURSES_EXT_FUNCS != 0)
1221
1338
  int            wresize(int newLines, int newColumns) {
1222
1339
    return ::wresize(w, newLines, newColumns); }
1223
1340
#endif