* Copyright (c) 1981, 1993, 1994

/* $NetBSD: curses.h,v 1.133 2024/12/05 04:08:12 blymn Exp $ */

/*
* Copyright (c) 1981, 1993, 1994
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)curses.h 8.5 (Berkeley) 4/29/95
*
* Modified by Ruibiao Qiu <[email protected],[email protected]> 2005
* to add wide-character support
* - Add complex character structure (cchar_t)
* - Add definitions of wide-character routines
* - Add KEY_CODE_YES
*/

#ifndef _CURSES_H_
#define _CURSES_H_

#include <sys/types.h>
#include <sys/cdefs.h>
#include <wchar.h>

#include <stdio.h>
#include <stdbool.h>

/*
* attr_t must be the same size as wchar_t (see <wchar.h>) to avoid padding
* in __LDATA.
*/
typedef wchar_t chtype;
typedef wchar_t attr_t;

#if !defined(HAVE_WCHAR) && !defined(DISABLE_WCHAR)
#define HAVE_WCHAR 1
#endif

#ifdef HAVE_WCHAR
/*
* The complex character structure required by the X/Open reference and used
* in functions such as in_wchstr(). It includes a string of up to 8 wide
* characters and its length, an attribute, and a color-pair.
*/
#define CURSES_CCHAR_MAX 8
#define CCHARW_MAX 5
typedef struct {
attr_t attributes; /* character attributes */
unsigned elements; /* number of wide chars in
vals[] */
wchar_t vals[CURSES_CCHAR_MAX]; /* wide chars including
non-spacing */
} cchar_t;
#else
typedef chtype cchar_t;
#endif /* HAVE_WCHAR */

#ifndef TRUE
#define TRUE (/*CONSTCOND*/1)
#endif
#ifndef FALSE
#define FALSE (/*CONSTCOND*/0)
#endif

#ifndef _CURSES_PRIVATE

#define _puts(s) tputs(s, 0, __cputchar)
#define _putchar(c) __cputchar(c)

/* Old-style terminal modes access. */
#define crmode() cbreak()
#define nocrmode() nocbreak()
#endif /* _CURSES_PRIVATE */

/* symbols for values returned by getch in keypad mode */
#define KEY_MIN 0x101 /* minimum extended key value */
#define KEY_BREAK 0x101 /* break key */
#define KEY_DOWN 0x102 /* down arrow */
#define KEY_UP 0x103 /* up arrow */
#define KEY_LEFT 0x104 /* left arrow */
#define KEY_RIGHT 0x105 /* right arrow*/
#define KEY_HOME 0x106 /* home key */
#define KEY_BACKSPACE 0x107 /* Backspace */

/* First function key (block of 64 follow) */
#define KEY_F0 0x108
/* Function defining other function key values */
#define KEY_F(n) (KEY_F0+(n))

#define KEY_DL 0x148 /* Delete Line */
#define KEY_IL 0x149 /* Insert Line*/
#define KEY_DC 0x14A /* Delete Character */
#define KEY_IC 0x14B /* Insert Character */
#define KEY_EIC 0x14C /* Exit Insert Char mode */
#define KEY_CLEAR 0x14D /* Clear screen */
#define KEY_EOS 0x14E /* Clear to end of screen */
#define KEY_EOL 0x14F /* Clear to end of line */
#define KEY_SF 0x150 /* Scroll one line forward */
#define KEY_SR 0x151 /* Scroll one line back */
#define KEY_NPAGE 0x152 /* Next Page */
#define KEY_PPAGE 0x153 /* Prev Page */
#define KEY_STAB 0x154 /* Set Tab */
#define KEY_CTAB 0x155 /* Clear Tab */
#define KEY_CATAB 0x156 /* Clear All Tabs */
#define KEY_ENTER 0x157 /* Enter or Send */
#define KEY_SRESET 0x158 /* Soft Reset */
#define KEY_RESET 0x159 /* Hard Reset */
#define KEY_PRINT 0x15A /* Print */
#define KEY_LL 0x15B /* Home Down */

/*
* "Keypad" keys are arranged like this:
*
* A1 up A3
* left B2 right
* C1 down C3
*
*/
#define KEY_A1 0x15C /* Keypad upper left */
#define KEY_A3 0x15D /* Keypad upper right */
#define KEY_B2 0x15E /* Keypad centre key */
#define KEY_C1 0x15F /* Keypad lower left */
#define KEY_C3 0x160 /* Keypad lower right */

#define KEY_BTAB 0x161 /* Back Tab */
#define KEY_BEG 0x162 /* Begin key */
#define KEY_CANCEL 0x163 /* Cancel key */
#define KEY_CLOSE 0x164 /* Close Key */
#define KEY_COMMAND 0x165 /* Command Key */
#define KEY_COPY 0x166 /* Copy key */
#define KEY_CREATE 0x167 /* Create key */
#define KEY_END 0x168 /* End key */
#define KEY_EXIT 0x169 /* Exit key */
#define KEY_FIND 0x16A /* Find key */
#define KEY_HELP 0x16B /* Help key */
#define KEY_MARK 0x16C /* Mark key */
#define KEY_MESSAGE 0x16D /* Message key */
#define KEY_MOVE 0x16E /* Move key */
#define KEY_NEXT 0x16F /* Next Object key */
#define KEY_OPEN 0x170 /* Open key */
#define KEY_OPTIONS 0x171 /* Options key */
#define KEY_PREVIOUS 0x172 /* Previous Object key */
#define KEY_REDO 0x173 /* Redo key */
#define KEY_REFERENCE 0x174 /* Ref Key */
#define KEY_REFRESH 0x175 /* Refresh key */
#define KEY_REPLACE 0x176 /* Replace key */
#define KEY_RESTART 0x177 /* Restart key */
#define KEY_RESUME 0x178 /* Resume key */
#define KEY_SAVE 0x179 /* Save key */
#define KEY_SBEG 0x17A /* Shift Begin key */
#define KEY_SCANCEL 0x17B /* Shift Cancel key */
#define KEY_SCOMMAND 0x17C /* Shift Command key */
#define KEY_SCOPY 0x17D /* Shift Copy key */
#define KEY_SCREATE 0x17E /* Shift Create key */
#define KEY_SDC 0x17F /* Shift Delete Character */
#define KEY_SDL 0x180 /* Shift Delete Line */
#define KEY_SELECT 0x181 /* Select key */
#define KEY_SEND 0x182 /* Send key */
#define KEY_SEOL 0x183 /* Shift Clear Line key */
#define KEY_SEXIT 0x184 /* Shift Exit key */
#define KEY_SFIND 0x185 /* Shift Find key */
#define KEY_SHELP 0x186 /* Shift Help key */
#define KEY_SHOME 0x187 /* Shift Home key */
#define KEY_SIC 0x188 /* Shift Input key */
#define KEY_SLEFT 0x189 /* Shift Left Arrow key */
#define KEY_SMESSAGE 0x18A /* Shift Message key */
#define KEY_SMOVE 0x18B /* Shift Move key */
#define KEY_SNEXT 0x18C /* Shift Next key */
#define KEY_SOPTIONS 0x18D /* Shift Options key */
#define KEY_SPREVIOUS 0x18E /* Shift Previous key */
#define KEY_SPRINT 0x18F /* Shift Print key */
#define KEY_SREDO 0x190 /* Shift Redo key */
#define KEY_SREPLACE 0x191 /* Shift Replace key */
#define KEY_SRIGHT 0x192 /* Shift Right Arrow key */
#define KEY_SRSUME 0x193 /* Shift Resume key */
#define KEY_SSAVE 0x194 /* Shift Save key */
#define KEY_SSUSPEND 0x195 /* Shift Suspend key */
#define KEY_SUNDO 0x196 /* Shift Undo key */
#define KEY_SUSPEND 0x197 /* Suspend key */
#define KEY_UNDO 0x198 /* Undo key */
#define KEY_MOUSE 0x199 /* Mouse event has occurred */
#define KEY_RESIZE 0x200 /* Resize event has occurred */
#define KEY_MAX 0x240 /* maximum extended key value */
#define KEY_CODE_YES 0x241 /* A function key was pressed */

#include <unctrl.h>

/*
* A window is an array of __LINE structures pointed to by the 'lines' pointer.
* A line is an array of __LDATA structures pointed to by the 'line' pointer.
*/

/*
* Definitions for characters and attributes in __LDATA
*/
#define __CHARTEXT 0x000000ff /* bits for 8-bit characters */
#define __NORMAL 0x00000000 /* Added characters are normal. */
#define __STANDOUT 0x00000100 /* Added characters are standout. */
#define __UNDERSCORE 0x00000200 /* Added characters are underscored. */
#define __REVERSE 0x00000400 /* Added characters are reverse
video. */
#define __BLINK 0x00000800 /* Added characters are blinking. */
#define __DIM 0x00001000 /* Added characters are dim. */
#define __BOLD 0x00002000 /* Added characters are bold. */
#define __BLANK 0x00004000 /* Added characters are blanked. */
#define __PROTECT 0x00008000 /* Added characters are protected. */
#define __ALTCHARSET 0x00010000 /* Added characters are ACS */
#define __COLOR 0x03fe0000 /* Color bits */
#define __ATTRIBUTES 0x03ffff00 /* All 8-bit attribute bits */
#ifdef HAVE_WCHAR
#define __ACS_IS_WACS 0x04000000 /* internal: use wacs table for ACS char */
#endif

typedef struct __ldata __LDATA;
typedef struct __line __LINE;
typedef struct __window WINDOW;
typedef struct __screen SCREEN;

/*
* Attribute definitions
*/
#define A_NORMAL __NORMAL
#define A_STANDOUT __STANDOUT
#define A_UNDERLINE __UNDERSCORE
#define A_REVERSE __REVERSE
#define A_BLINK __BLINK
#define A_DIM __DIM
#define A_BOLD __BOLD
#define A_BLANK __BLANK
#define A_INVIS __BLANK
#define A_PROTECT __PROTECT
#define A_ALTCHARSET __ALTCHARSET
#define A_ATTRIBUTES __ATTRIBUTES
#define A_CHARTEXT __CHARTEXT
#define A_COLOR __COLOR

#ifdef HAVE_WCHAR
#define WA_ATTRIBUTES 0x03ffffff /* Wide character attributes mask */
#define WA_NORMAL __NORMAL
#define WA_STANDOUT __STANDOUT /* Best highlighting mode */
#define WA_UNDERLINE __UNDERSCORE /* Underlining */
#define WA_REVERSE __REVERSE /* Reverse video */
#define WA_BLINK __BLINK /* Blinking */
#define WA_DIM __DIM /* Half bright */
#define WA_BOLD __BOLD /* Extra bright or bold */
#define WA_INVIS __BLANK /* Invisible */
#define WA_PROTECT __PROTECT /* Protected */
#define WA_ALTCHARSET __ALTCHARSET /* Alternate character set */
#define WA_LOW 0x00000002 /* Low highlight */
#define WA_TOP 0x00000004 /* Top highlight */
#define WA_HORIZONTAL 0x00000008 /* Horizontal highlight */
#define WA_VERTICAL 0x00000010 /* Vertical highlight */
#define WA_LEFT 0x00000020 /* Left highlight */
#define WA_RIGHT 0x00000040 /* Right highlight */
#endif /* HAVE_WCHAR */

/*
* Alternate character set definitions
*/

#define NUM_ACS 128

__BEGIN_DECLS
extern chtype _acs_char[NUM_ACS];
__END_DECLS
#ifdef __cplusplus
#define __UC_CAST(a) static_cast<unsigned char>(a)
#else
#define __UC_CAST(a) (unsigned char)(a)
#endif

/* Standard definitions */
#define ACS_RARROW _acs_char[__UC_CAST('+')]
#define ACS_LARROW _acs_char[__UC_CAST(',')]
#define ACS_UARROW _acs_char[__UC_CAST('-')]
#define ACS_DARROW _acs_char[__UC_CAST('.')]
#define ACS_BLOCK _acs_char[__UC_CAST('0')]
#define ACS_DIAMOND _acs_char[__UC_CAST('`')]
#define ACS_CKBOARD _acs_char[__UC_CAST('a')]
#define ACS_DEGREE _acs_char[__UC_CAST('f')]
#define ACS_PLMINUS _acs_char[__UC_CAST('g')]
#define ACS_BOARD _acs_char[__UC_CAST('h')]
#define ACS_LANTERN _acs_char[__UC_CAST('i')]
#define ACS_LRCORNER _acs_char[__UC_CAST('j')]
#define ACS_URCORNER _acs_char[__UC_CAST('k')]
#define ACS_ULCORNER _acs_char[__UC_CAST('l')]
#define ACS_LLCORNER _acs_char[__UC_CAST('m')]
#define ACS_PLUS _acs_char[__UC_CAST('n')]
#define ACS_HLINE _acs_char[__UC_CAST('q')]
#define ACS_S1 _acs_char[__UC_CAST('o')]
#define ACS_S9 _acs_char[__UC_CAST('s')]
#define ACS_LTEE _acs_char[__UC_CAST('t')]
#define ACS_RTEE _acs_char[__UC_CAST('u')]
#define ACS_BTEE _acs_char[__UC_CAST('v')]
#define ACS_TTEE _acs_char[__UC_CAST('w')]
#define ACS_VLINE _acs_char[__UC_CAST('x')]
#define ACS_BULLET _acs_char[__UC_CAST('~')]

/* Extensions */
#define ACS_S3 _acs_char[__UC_CAST('p')]
#define ACS_S7 _acs_char[__UC_CAST('r')]
#define ACS_LEQUAL _acs_char[__UC_CAST('y')]
#define ACS_GEQUAL _acs_char[__UC_CAST('z')]
#define ACS_PI _acs_char[__UC_CAST('{')]
#define ACS_NEQUAL _acs_char[__UC_CAST('|')]
#define ACS_STERLING _acs_char[__UC_CAST('}')]

#ifdef HAVE_WCHAR
__BEGIN_DECLS
extern cchar_t _wacs_char[NUM_ACS];
__END_DECLS

#define WACS_RARROW (&_wacs_char[(unsigned char)'+'])
#define WACS_LARROW (&_wacs_char[(unsigned char)','])
#define WACS_UARROW (&_wacs_char[(unsigned char)'-'])
#define WACS_DARROW (&_wacs_char[(unsigned char)'.'])
#define WACS_BLOCK (&_wacs_char[(unsigned char)'0'])
#define WACS_DIAMOND (&_wacs_char[(unsigned char)'`'])
#define WACS_CKBOARD (&_wacs_char[(unsigned char)'a'])
#define WACS_DEGREE (&_wacs_char[(unsigned char)'f'])
#define WACS_PLMINUS (&_wacs_char[(unsigned char)'g'])
#define WACS_BOARD (&_wacs_char[(unsigned char)'h'])
#define WACS_LANTERN (&_wacs_char[(unsigned char)'i'])
#define WACS_LRCORNER (&_wacs_char[(unsigned char)'j'])
#define WACS_URCORNER (&_wacs_char[(unsigned char)'k'])
#define WACS_ULCORNER (&_wacs_char[(unsigned char)'l'])
#define WACS_LLCORNER (&_wacs_char[(unsigned char)'m'])
#define WACS_PLUS (&_wacs_char[(unsigned char)'n'])
#define WACS_HLINE (&_wacs_char[(unsigned char)'q'])
#define WACS_S1 (&_wacs_char[(unsigned char)'o'])
#define WACS_S9 (&_wacs_char[(unsigned char)'s'])
#define WACS_LTEE (&_wacs_char[(unsigned char)'t'])
#define WACS_RTEE (&_wacs_char[(unsigned char)'u'])
#define WACS_BTEE (&_wacs_char[(unsigned char)'v'])
#define WACS_TTEE (&_wacs_char[(unsigned char)'w'])
#define WACS_VLINE (&_wacs_char[(unsigned char)'x'])
#define WACS_BULLET (&_wacs_char[(unsigned char)'~'])
#define WACS_S3 (&_wacs_char[(unsigned char)'p'])
#define WACS_S7 (&_wacs_char[(unsigned char)'r'])
#define WACS_LEQUAL (&_wacs_char[(unsigned char)'y'])
#define WACS_GEQUAL (&_wacs_char[(unsigned char)'z'])
#define WACS_PI (&_wacs_char[(unsigned char)'{'])
#define WACS_NEQUAL (&_wacs_char[(unsigned char)'|'])
#define WACS_STERLING (&_wacs_char[(unsigned char)'}'])
#endif /* HAVE_WCHAR */

/* System V compatibility */
#define ACS_SBBS ACS_LRCORNER
#define ACS_BBSS ACS_URCORNER
#define ACS_BSSB ACS_ULCORNER
#define ACS_SSBB ACS_LLCORNER
#define ACS_SSSS ACS_PLUS
#define ACS_BSBS ACS_HLINE
#define ACS_SSSB ACS_LTEE
#define ACS_SBSS ACS_RTEE
#define ACS_SSBS ACS_BTEE
#define ACS_BSSS ACS_TTEE
#define ACS_SBSB ACS_VLINE
#define _acs_map _acs_char

/*
* Color definitions (ANSI color numbers)
*/

#define COLOR_BLACK 0x00
#define COLOR_RED 0x01
#define COLOR_GREEN 0x02
#define COLOR_YELLOW 0x03
#define COLOR_BLUE 0x04
#define COLOR_MAGENTA 0x05
#define COLOR_CYAN 0x06
#define COLOR_WHITE 0x07

#ifdef __cplusplus
#define __UINT32_CAST(a) static_cast<uint32_t>(a)
#else
#define __UINT32_CAST(a) (uint32_t)(a)
#endif
#define COLOR_PAIR(n) (((__UINT32_CAST(n)) << 17) & A_COLOR)
#define PAIR_NUMBER(n) (((__UINT32_CAST(n)) & A_COLOR) >> 17)

/* Curses external declarations. */
__BEGIN_DECLS
extern WINDOW *curscr; /* Current screen. */
extern WINDOW *stdscr; /* Standard screen. */

extern int __tcaction; /* If terminal hardware set. */

extern int COLS; /* Columns on the screen. */
extern int LINES; /* Lines on the screen. */
extern int COLORS; /* Max colors on the screen. */
extern int COLOR_PAIRS; /* Max color pairs on the screen. */

extern int ESCDELAY; /* Delay between keys in esc seq's. */
extern int TABSIZE; /* Size of a tab. */
__END_DECLS

#ifndef OK
#define ERR (-1) /* Error return. */
#define OK (0) /* Success return. */
#endif

/*
* The following have, traditionally, been macros but X/Open say they
* need to be functions. Keep the old macros for debugging.
*/
#ifdef _CURSES_USE_MACROS
/* Standard screen pseudo functions. */
#define addbytes(s, n) __waddbytes(stdscr, s, n, 0)
#define addch(ch) waddch(stdscr, ch)
#define addchnstr(s, n) waddchnstr(stdscr, s, n)
#define addchstr(s) waddchnstr(stdscr, s, -1)
#define addnstr(s, n) waddnstr(stdscr, s, n)
#define addstr(s) waddnstr(stdscr, s, -1)
#define attr_get(a, p, o) wattr_get(stdscr, a, p, o)
#define attr_off(a, o) wattr_off(stdscr, a, o)
#define attr_on(a, o) wattr_on(stdscr, a, o)
#define attr_set(a, p, o) wattr_set(stdscr, a, p, o)
#define attroff(attr) wattroff(stdscr, attr)
#define attron(attr) wattron(stdscr, attr)
#define attrset(attr) wattrset(stdscr, attr)
#define bkgd(ch) wbkgd(stdscr, ch)
#define bkgdset(ch) wbkgdset(stdscr, ch)
#define border(l, r, t, b, tl, tr, bl, br) \
wborder(stdscr, l, r, t, b, tl, tr, bl, br)
#define clear() wclear(stdscr)
#define clrtobot() wclrtobot(stdscr)
#define clrtoeol() wclrtoeol(stdscr)
#define color_set(c, o) wcolor_set(stdscr, c, o)
#define delch() wdelch(stdscr)
#define deleteln() wdeleteln(stdscr)
#define echochar(c) wechochar(stdscr, c)
#define erase() werase(stdscr)
#define getch() wgetch(stdscr)
#define getnstr(s, n) wgetnstr(stdscr, s, n)
#define getstr(s) wgetstr(stdscr, s)
#define inch() winch(stdscr)
#define inchnstr(c) winchnstr(stdscr, c)
#define inchstr(c) winchstr(stdscr, c)
#define innstr(s, n) winnstr(stdscr, s, n)
#define insch(ch) winsch(stdscr, ch)
#define insdelln(n) winsdelln(stdscr, n)
#define insertln() winsertln(stdscr)
#define instr(s) winstr(stdscr, s)
#define move(y, x) wmove(stdscr, y, x)
#define refresh() wrefresh(stdscr)
#define scrl(n) wscrl(stdscr, n)
#define setscrreg(t, b) wsetscrreg(stdscr, t, b)
#define standend() wstandend(stdscr)
#define standout() wstandout(stdscr)
#define timeout(delay) wtimeout(stdscr, delay)
#define underscore() wunderscore(stdscr)
#define underend() wunderend(stdscr)
#define waddbytes(w, s, n) __waddbytes(w, s, n, 0)
#define waddstr(w, s) waddnstr(w, s, -1)

/* Standard screen plus movement pseudo functions. */
#define mvaddbytes(y, x, s, n) mvwaddbytes(stdscr, y, x, s, n)
#define mvaddch(y, x, ch) mvwaddch(stdscr, y, x, ch)
#define mvaddchnstr(y, x, s, n) mvwaddchnstr(stdscr, y, x, s, n)
#define mvaddchstr(y, x, s) mvwaddchstr(stdscr, y, x, s)
#define mvaddnstr(y, x, s, n) mvwaddnstr(stdscr, y, x, s, n)
#define mvaddstr(y, x, s) mvwaddstr(stdscr, y, x, s)
#define mvdelch(y, x) mvwdelch(stdscr, y, x)
#define mvgetch(y, x) mvwgetch(stdscr, y, x)
#define mvgetnstr(y, x, s, n) mvwgetnstr(stdscr, y, x, s, n)
#define mvgetstr(y, x, s) mvwgetstr(stdscr, y, x, s)
#define mvinch(y, x) mvwinch(stdscr, y, x)
#define mvinchnstr(y, x, c, n) mvwinchnstr(stdscr, y, x, c, n)
#define mvinchstr(y, x, c) mvwinchstr(stdscr, y, x, c)
#define mvinnstr(y, x, s, n) mvwinnstr(stdscr, y, x, s, n)
#define mvinsch(y, x, c) mvwinsch(stdscr, y, x, c)
#define mvinstr(y, x, s) mvwinstr(stdscr, y, x, s)
#define mvwaddbytes(w, y, x, s, n) \
(wmove(w, y, x) == ERR ? ERR : __waddbytes(w, s, n, 0))
#define mvwaddch(w, y, x, ch) \
(wmove(w, y, x) == ERR ? ERR : waddch(w, ch))
#define mvwaddchnstr(w, y, x, s, n) \
(wmove(w, y, x) == ERR ? ERR : waddchnstr(w, s, n))
#define mvwaddchstr(w, y, x, s) \
(wmove(w, y, x) == ERR ? ERR : waddchnstr(w, s, -1))
#define mvwaddnstr(w, y, x, s, n) \
(wmove(w, y, x) == ERR ? ERR : waddnstr(w, s, n))
#define mvwaddstr(w, y, x, s) \
(wmove(w, y, x) == ERR ? ERR : waddnstr(w, s, -1))
#define mvwdelch(w, y, x) \
(wmove(w, y, x) == ERR ? ERR : wdelch(w))
#define mvwgetch(w, y, x) \
(wmove(w, y, x) == ERR ? ERR : wgetch(w))
#define mvwgetnstr(w, y, x, s, n) \
(wmove(w, y, x) == ERR ? ERR : wgetnstr(w, s, n))
#define mvwgetstr(w, y, x, s) \
(wmove(w, y, x) == ERR ? ERR : wgetstr(w, s))
#define mvwinch(w, y, x) \
(wmove(w, y, x) == ERR ? ERR : winch(w))
#define mvwinchnstr(w, y, x, c, n) \
(wmove(w, y, x) == ERR ? ERR : winchnstr(w, c, n))
#define mvwinchstr(w, y, x, s) \
(wmove(w, y, x) == ERR ? ERR : winchstr(w, c))
#define mvwinnstr(w, y, x, s, n) \
(wmove(w, y, x) == ERR ? ERR : winnstr(w, s, n))
#define mvwinsch(w, y, x, c) \
(wmove(w, y, x) == ERR ? ERR : winsch(w, c))
#define mvwinstr(w, y, x, s) \
(wmove(w, y, x) == ERR ? ERR : winstr(w, s))

/* Miscellaneous. */
#define noqiflush() intrflush(stdscr, FALSE)
#define qiflush() intrflush(stdscr, TRUE)

#else
/* Use functions not macros... */
__BEGIN_DECLS
int addbytes(const char *, int);
int addch(chtype);
int addchnstr(const chtype *, int);
int addchstr(const chtype *);
int addnstr(const char *, int);
int addstr(const char *);
int attr_get(attr_t *, short *, void *);
int attr_off(attr_t, void *);
int attr_on(attr_t, void *);
int attr_set(attr_t, short, void *);
int attroff(int);
int attron(int);
int attrset(int);
int bkgd(chtype);
void bkgdset(chtype);
int border(chtype, chtype, chtype, chtype,
chtype, chtype, chtype, chtype);
int clear(void);
int clrtobot(void);
int clrtoeol(void);
int color_set(short, void *);
int delch(void);
int deleteln(void);
int echochar(const chtype);
int erase(void);
int getch(void);
int getnstr(char *, int);
int getscrreg(int *, int *);
int getstr(char *);
chtype inch(void);
int inchnstr(chtype *, int);
int inchstr(chtype *);
int innstr(char *, int);
int insch(chtype);
int insdelln(int);
int insertln(void);
int instr(char *);
int move(int, int);
int refresh(void);
int scrl(int);
int setscrreg(int, int);
int standend(void);
int standout(void);
void timeout(int);
int underscore(void);
int underend(void);
int waddbytes(WINDOW *, const char *, int);
int waddstr(WINDOW *, const char *);

/* Standard screen plus movement functions. */
int mvaddbytes(int, int, const char *, int);
int mvaddch(int, int, chtype);
int mvaddchnstr(int, int, const chtype *, int);
int mvaddchstr(int, int, const chtype *);
int mvaddnstr(int, int, const char *, int);
int mvaddstr(int, int, const char *);
int mvdelch(int, int);
int mvgetch(int, int);
int mvgetnstr(int, int, char *, int);
int mvgetstr(int, int, char *);
chtype mvinch(int, int);
int mvinchnstr(int, int, chtype *, int);
int mvinchstr(int, int, chtype *);
int mvinnstr(int, int, char *, int);
int mvinsch(int, int, chtype);
int mvinstr(int, int, char *);

int mvwaddbytes(WINDOW *, int, int, const char *, int);
int mvwaddch(WINDOW *, int, int, chtype);
int mvwaddchnstr(WINDOW *, int, int, const chtype *, int);
int mvwaddchstr(WINDOW *, int, int, const chtype *);
int mvwaddnstr(WINDOW *, int, int, const char *, int);
int mvwaddstr(WINDOW *, int, int, const char *);
int mvwdelch(WINDOW *, int, int);
int mvwgetch(WINDOW *, int, int);
int mvwgetnstr(WINDOW *, int, int, char *, int);
int mvwgetstr(WINDOW *, int, int, char *);
chtype mvwinch(WINDOW *, int, int);
int mvwinsch(WINDOW *, int, int, chtype);
__END_DECLS
#endif /* _CURSES_USE_MACROS */

#define getyx(w, y, x) (y) = getcury(w), (x) = getcurx(w)
#define getbegyx(w, y, x) (y) = getbegy(w), (x) = getbegx(w)
#define getmaxyx(w, y, x) (y) = getmaxy(w), (x) = getmaxx(w)
#define getparyx(w, y, x) (y) = getpary(w), (x) = getparx(w)

#define getsyx(y, x) \
do { \
if (is_leaveok(curscr)) \
(y) = (x) = -1; \
else \
getyx(curscr,(y), (x)); \
} while(0 /* CONSTCOND */)
#define setsyx(y, x) \
do { \
if ((y) == -1 && (x) == -1) \
leaveok(curscr, TRUE); \
else { \
leaveok(curscr, FALSE); \
wmove(curscr, (y), (x)); \
} \
} while(0 /* CONSTCOND */)

/* Public functions. */
__BEGIN_DECLS
int assume_default_colors(short, short);
int baudrate(void);
int beep(void);
int box(WINDOW *, chtype, chtype);
bool can_change_color(void);
int cbreak(void);
int clearok(WINDOW *, bool);
int color_content(short, short *, short *, short *);
int copywin(const WINDOW *, WINDOW *, int, int, int, int, int, int, int);
int curs_set(int);
int def_prog_mode(void);
int def_shell_mode(void);
int define_key(const char *, int);
int delay_output(int);
void delscreen(SCREEN *);
int delwin(WINDOW *);
WINDOW *derwin(WINDOW *, int, int, int, int);
WINDOW *dupwin(WINDOW *);
int doupdate(void);
int echo(void);
int endwin(void);
char erasechar(void);
void filter(void);
int flash(void);
int flushinp(void);
int flushok(WINDOW *, bool);
char *fullname(const char *, char *);
chtype getattrs(WINDOW *);
chtype getbkgd(WINDOW *);
int getcury(WINDOW *);
int getcurx(WINDOW *);
int getbegy(WINDOW *);
int getbegx(WINDOW *);
int getmaxy(WINDOW *);
int getmaxx(WINDOW *);
int getpary(WINDOW *);
int getparx(WINDOW *);
int gettmode(void);
WINDOW *getwin(FILE *);
int halfdelay(int);
bool has_colors(void);
bool has_ic(void);
bool has_il(void);
int has_key(int);
int hline(chtype, int);
int idcok(WINDOW *, bool);
int idlok(WINDOW *, bool);
int immedok(WINDOW *, bool);
int init_color(short, short, short, short);
int init_pair(short, short, short);
WINDOW *initscr(void);
int intrflush(WINDOW *, bool);
bool isendwin(void);
bool is_linetouched(WINDOW *, int);
bool is_wintouched(WINDOW *);
bool is_term_resized(int, int);
int keyok(int, bool);
int keypad(WINDOW *, bool);
char *keyname(int);
char killchar(void);
int leaveok(WINDOW *, bool);
int meta(WINDOW *, bool);
int mvcur(int, int, int, int);
int mvderwin(WINDOW *, int, int);
int mvhline(int, int, chtype, int);
int mvprintw(int, int, const char *, ...) __printflike(3, 4);
int mvscanw(int, int, const char *, ...) __scanflike(3, 4);
int mvvline(int, int, chtype, int);
int mvwhline(WINDOW *, int, int, chtype, int);
int mvwvline(WINDOW *, int, int, chtype, int);
int mvwin(WINDOW *, int, int);
int mvwinchnstr(WINDOW *, int, int, chtype *, int);
int mvwinchstr(WINDOW *, int, int, chtype *);
int mvwinnstr(WINDOW *, int, int, char *, int);
int mvwinstr(WINDOW *, int, int, char *);
int mvwprintw(WINDOW *, int, int, const char *, ...) __printflike(4, 5);
int mvwscanw(WINDOW *, int, int, const char *, ...) __scanflike(4, 5);
int napms(int);
WINDOW *newpad(int, int);
SCREEN *newterm(const char *, FILE *, FILE *);
WINDOW *newwin(int, int, int, int);
int nl(void);
attr_t no_color_attributes(void);
int nocbreak(void);
int nodelay(WINDOW *, bool);
int noecho(void);
int nonl(void);
void noqiflush(void);
int noraw(void);
int notimeout(WINDOW *, bool);
int overlay(const WINDOW *, WINDOW *);
int overwrite(const WINDOW *, WINDOW *);
int pair_content(short, short *, short *);
int pechochar(WINDOW *, const chtype);
int pnoutrefresh(WINDOW *, int, int, int, int, int, int);
int prefresh(WINDOW *, int, int, int, int, int, int);
int printw(const char *, ...) __printflike(1, 2);
int putwin(WINDOW *, FILE *);
void qiflush(void);
int raw(void);
int redrawwin(WINDOW *);
int reset_prog_mode(void);
int reset_shell_mode(void);
int resetty(void);
int resizeterm(int, int);
int resize_term(int, int);
int ripoffline(int, int (*)(WINDOW *, int));
int savetty(void);
int scanw(const char *, ...) __scanflike(1, 2);
int scroll(WINDOW *);
int scrollok(WINDOW *, bool);
int setterm(const char *);
int set_escdelay(int);
int set_tabsize(int);
SCREEN *set_term(SCREEN *);
int start_color(void);
WINDOW *subpad(WINDOW *, int, int, int, int);
WINDOW *subwin(WINDOW *, int, int, int, int);
int syncok(WINDOW *, bool);
chtype termattrs(void);
attr_t term_attrs(void);
int touchline(WINDOW *, int, int);
int touchoverlap(WINDOW *, WINDOW *);
int touchwin(WINDOW *);
int typeahead(int);
int ungetch(int);
int untouchwin(WINDOW *);
int use_default_colors(void);
void use_env(bool);
int vline(chtype, int);
int vw_printw(WINDOW *, const char *, __va_list) __printflike(2, 0);
int vw_scanw(WINDOW *, const char *, __va_list) __scanflike(2, 0);
int vwprintw(WINDOW *, const char *, __va_list) __printflike(2, 0);
int vwscanw(WINDOW *, const char *, __va_list) __scanflike(2, 0);
int waddch(WINDOW *, chtype);
int waddchnstr(WINDOW *, const chtype *, int);
int waddchstr(WINDOW *, const chtype *);
int waddnstr(WINDOW *, const char *, int);
int wattr_get(WINDOW *, attr_t *, short *, void *);
int wattr_off(WINDOW *, attr_t, void *);
int wattr_on(WINDOW *, attr_t, void *);
int wattr_set(WINDOW *, attr_t, short, void *);
int wattroff(WINDOW *, int);
int wattron(WINDOW *, int);
int wattrset(WINDOW *, int);
int wbkgd(WINDOW *, chtype);
void wbkgdset(WINDOW *, chtype);
int wborder(WINDOW *, chtype, chtype, chtype, chtype, chtype, chtype,
chtype, chtype);
int wclear(WINDOW *);
int wclrtobot(WINDOW *);
int wclrtoeol(WINDOW *);
int wcolor_set(WINDOW *, short, void *);
void wcursyncup(WINDOW *);
int wdelch(WINDOW *);
int wdeleteln(WINDOW *);
int wechochar(WINDOW *, const chtype);
int werase(WINDOW *);
int wgetch(WINDOW *);
int wgetnstr(WINDOW *, char *, int);
int wgetscrreg(WINDOW *, int *, int *);
int wgetstr(WINDOW *, char *);
int whline(WINDOW *, chtype, int);
chtype winch(WINDOW *);
int winchnstr(WINDOW *, chtype *, int);
int winchstr(WINDOW *, chtype *);
int winnstr(WINDOW *, char *, int);
int winsch(WINDOW *, chtype);
int winsdelln(WINDOW *, int);
int winsertln(WINDOW *);
int winstr(WINDOW *, char *);
int wmove(WINDOW *, int, int);
int wnoutrefresh(WINDOW *);
int wprintw(WINDOW *, const char *, ...) __printflike(2, 3);
int wredrawln(WINDOW *, int, int);
int wrefresh(WINDOW *);
int wresize(WINDOW *, int, int);
int wscanw(WINDOW *, const char *, ...) __scanflike(2, 3);
int wscrl(WINDOW *, int);
int wsetscrreg(WINDOW *, int, int);
int wstandend(WINDOW *);
int wstandout(WINDOW *);
void wsyncdown(WINDOW *);
void wsyncup(WINDOW *);
void wtimeout(WINDOW *, int);
int wtouchln(WINDOW *, int, int, int);
int wunderend(WINDOW *);
int wunderscore(WINDOW *);
int wvline(WINDOW *, chtype, int);

int insnstr(const char *, int);
int insstr(const char *);
int mvinsnstr(int, int, const char *, int);
int mvinsstr(int, int, const char *);
int mvwinsnstr(WINDOW *, int, int, const char *, int);
int mvwinsstr(WINDOW *, int, int, const char *);
int winsnstr(WINDOW *, const char *, int);
int winsstr(WINDOW *, const char *);

int chgat(int, attr_t, short, const void *);
int wchgat(WINDOW *, int, attr_t, short, const void *);
int mvchgat(int, int, int, attr_t, short, const void *);
int mvwchgat(WINDOW *, int, int, int, attr_t, short, const void *);

/* Soft Label Keys. */
int slk_attroff(const chtype);
int slk_attr_off(const attr_t, void *);
int slk_attron(const chtype);
int slk_attr_on(const attr_t, void *);
int slk_attrset(const chtype);
int slk_attr_set(const attr_t, short, void *);
int slk_clear(void);
int slk_color(short);
int slk_init(int);
char *slk_label(int);
int slk_noutrefresh(void);
int slk_refresh(void);
int slk_restore(void);
int slk_set(int, const char *, int);
int slk_touch(void);
int slk_wset(int, const wchar_t *, int);

/* wide-character support routines */
/* return ERR when HAVE_WCHAR is not defined */
/* add */
int add_wch(const cchar_t *);
int wadd_wch(WINDOW *, const cchar_t *);
int mvadd_wch(int, int, const cchar_t *);
int mvwadd_wch(WINDOW *, int, int, const cchar_t *);

int add_wchnstr(const cchar_t *, int);
int add_wchstr(const cchar_t *);
int wadd_wchnstr(WINDOW *, const cchar_t *, int);
int wadd_wchstr(WINDOW *, const cchar_t *);
int mvadd_wchnstr(int, int, const cchar_t *, int);
int mvadd_wchstr(int, int, const cchar_t *);
int mvwadd_wchnstr(WINDOW *, int, int, const cchar_t *, int);
int mvwadd_wchstr(WINDOW *, int, int, const cchar_t *);

int addnwstr(const wchar_t *, int);
int addwstr(const wchar_t *);
int mvaddnwstr(int, int x, const wchar_t *, int);
int mvaddwstr(int, int x, const wchar_t *);
int mvwaddnwstr(WINDOW *, int, int, const wchar_t *, int);
int mvwaddwstr(WINDOW *, int, int, const wchar_t *);
int waddnwstr(WINDOW *, const wchar_t *, int);
int waddwstr(WINDOW *, const wchar_t *);

int echo_wchar(const cchar_t *);
int wecho_wchar(WINDOW *, const cchar_t *);
int pecho_wchar(WINDOW *, const cchar_t *);

/* insert */
int ins_wch(const cchar_t *);
int wins_wch(WINDOW *, const cchar_t *);
int mvins_wch(int, int, const cchar_t *);
int mvwins_wch(WINDOW *, int, int, const cchar_t *);

int ins_nwstr(const wchar_t *, int);
int ins_wstr(const wchar_t *);
int mvins_nwstr(int, int, const wchar_t *, int);
int mvins_wstr(int, int, const wchar_t *);
int mvwins_nwstr(WINDOW *, int, int, const wchar_t *, int);
int mvwins_wstr(WINDOW *, int, int, const wchar_t *);
int wins_nwstr(WINDOW *, const wchar_t *, int);
int wins_wstr(WINDOW *, const wchar_t *);

/* input */
int get_wch(wint_t *);
int unget_wch(const wchar_t);
int mvget_wch(int, int, wint_t *);
int mvwget_wch(WINDOW *, int, int, wint_t *);
int wget_wch(WINDOW *, wint_t *);

int getn_wstr(wchar_t *, int);
int get_wstr(wchar_t *);
int mvgetn_wstr(int, int, wchar_t *, int);
int mvget_wstr(int, int, wchar_t *);
int mvwgetn_wstr(WINDOW *, int, int, wchar_t *, int);
int mvwget_wstr(WINDOW *, int, int, wchar_t *);
int wgetn_wstr(WINDOW *, wchar_t *, int);
int wget_wstr(WINDOW *, wchar_t *);

int in_wch(cchar_t *);
int mvin_wch(int, int, cchar_t *);
int mvwin_wch(WINDOW *, int, int, cchar_t *);
int win_wch(WINDOW *, cchar_t *);

int in_wchnstr(cchar_t *, int);
int in_wchstr(cchar_t *);
int mvin_wchnstr(int, int, cchar_t *, int);
int mvin_wchstr(int, int, cchar_t *);
int mvwin_wchnstr(WINDOW *, int, int, cchar_t *, int);
int mvwin_wchstr(WINDOW *, int, int, cchar_t *);
int win_wchnstr(WINDOW *, cchar_t *, int);
int win_wchstr(WINDOW *, cchar_t *);

int innwstr(wchar_t *, int);
int inwstr(wchar_t *);
int mvinnwstr(int, int, wchar_t *, int);
int mvinwstr(int, int, wchar_t *);
int mvwinnwstr(WINDOW *, int, int, wchar_t *, int);
int mvwinwstr(WINDOW *, int, int, wchar_t *);
int winnwstr(WINDOW *, wchar_t *, int);
int winwstr(WINDOW *, wchar_t *);

/* cchar handling */
int setcchar(cchar_t *, const wchar_t *, const attr_t, short, const void *);
int getcchar(const cchar_t *, wchar_t *, attr_t *, short *, void *);

/* misc */
char *key_name( wchar_t );
int border_set(const cchar_t *, const cchar_t *, const cchar_t *,
const cchar_t *, const cchar_t *, const cchar_t *,
const cchar_t *, const cchar_t *);
int wborder_set(WINDOW *, const cchar_t *, const cchar_t *,
const cchar_t *, const cchar_t *, const cchar_t *,
const cchar_t *, const cchar_t *, const cchar_t *);
int box_set(WINDOW *, const cchar_t *, const cchar_t *);
int erasewchar(wchar_t *);
int killwchar(wchar_t *);
int hline_set(const cchar_t *, int);
int mvhline_set(int, int, const cchar_t *, int);
int mvvline_set(int, int, const cchar_t *, int);
int mvwhline_set(WINDOW *, int, int, const cchar_t *, int);
int mvwvline_set(WINDOW *, int, int, const cchar_t *, int);
int vline_set(const cchar_t *, int);
int whline_set(WINDOW *, const cchar_t *, int);
int wvline_set(WINDOW *, const cchar_t *, int);
int bkgrnd(const cchar_t *);
void bkgrndset(const cchar_t *);
int getbkgrnd(cchar_t *);
int wbkgrnd(WINDOW *, const cchar_t *);
void wbkgrndset(WINDOW *, const cchar_t *);
int wgetbkgrnd(WINDOW *, cchar_t *);

/* ncurses window tests */
bool is_keypad(const WINDOW *);
bool is_leaveok(const WINDOW *);
bool is_pad(const WINDOW *);

/* ncurses mouse support */
#define NB_MOUSE_MASK(b, m) ((m) << (((b) - 1) * 5))
#define NB_BUTTON_RELEASED 001L
#define NB_BUTTON_PRESSED 002L
#define NB_BUTTON_CLICKED 004L
#define NB_DOUBLE_CLICKED 010L
#define NB_TRIPLE_CLICKED 020L
#define NB_RESERVED_EVENT 040L

#define BUTTON1_RELEASED NB_MOUSE_MASK(1, NB_BUTTON_RELEASED)
#define BUTTON1_PRESSED NB_MOUSE_MASK(1, NB_BUTTON_PRESSED)
#define BUTTON1_CLICKED NB_MOUSE_MASK(1, NB_BUTTON_CLICKED)
#define BUTTON1_DOUBLE_CLICKED NB_MOUSE_MASK(1, NB_DOUBLE_CLICKED)
#define BUTTON1_TRIPLE_CLICKED NB_MOUSE_MASK(1, NB_TRIPLE_CLICKED)

#define BUTTON2_RELEASED NB_MOUSE_MASK(2, NB_BUTTON_RELEASED)
#define BUTTON2_PRESSED NB_MOUSE_MASK(2, NB_BUTTON_PRESSED)
#define BUTTON2_CLICKED NB_MOUSE_MASK(2, NB_BUTTON_CLICKED)
#define BUTTON2_DOUBLE_CLICKED NB_MOUSE_MASK(2, NB_DOUBLE_CLICKED)
#define BUTTON2_TRIPLE_CLICKED NB_MOUSE_MASK(2, NB_TRIPLE_CLICKED)

#define BUTTON3_RELEASED NB_MOUSE_MASK(3, NB_BUTTON_RELEASED)
#define BUTTON3_PRESSED NB_MOUSE_MASK(3, NB_BUTTON_PRESSED)
#define BUTTON3_CLICKED NB_MOUSE_MASK(3, NB_BUTTON_CLICKED)
#define BUTTON3_DOUBLE_CLICKED NB_MOUSE_MASK(3, NB_DOUBLE_CLICKED)
#define BUTTON3_TRIPLE_CLICKED NB_MOUSE_MASK(3, NB_TRIPLE_CLICKED)

#define BUTTON4_RELEASED NB_MOUSE_MASK(4, NB_BUTTON_RELEASED)
#define BUTTON4_PRESSED NB_MOUSE_MASK(4, NB_BUTTON_PRESSED)
#define BUTTON4_CLICKED NB_MOUSE_MASK(4, NB_BUTTON_CLICKED)
#define BUTTON4_DOUBLE_CLICKED NB_MOUSE_MASK(4, NB_DOUBLE_CLICKED)
#define BUTTON4_TRIPLE_CLICKED NB_MOUSE_MASK(4, NB_TRIPLE_CLICKED)

#define BUTTON5_RELEASED NB_MOUSE_MASK(5, NB_BUTTON_RELEASED)
#define BUTTON5_PRESSED NB_MOUSE_MASK(5, NB_BUTTON_PRESSED)
#define BUTTON5_CLICKED NB_MOUSE_MASK(5, NB_BUTTON_CLICKED)
#define BUTTON5_DOUBLE_CLICKED NB_MOUSE_MASK(5, NB_DOUBLE_CLICKED)
#define BUTTON5_TRIPLE_CLICKED NB_MOUSE_MASK(5, NB_TRIPLE_CLICKED)

#define BUTTON_CTRL NB_MOUSE_MASK(6, 0001L)
#define BUTTON_SHIFT NB_MOUSE_MASK(6, 0002L)
#define BUTTON_ALT NB_MOUSE_MASK(6, 0004L)
#define REPORT_MOUSE_POSITION NB_MOUSE_MASK(6, 0010L)
#define ALL_MOUSE_EVENTS (REPORT_MOUSE_POSITION - 1)

#define BUTTON_RELEASE(e, x) ((e) & NB_MOUSE_MASK(x, 001))
#define BUTTON_PRESS(e, x) ((e) & NB_MOUSE_MASK(x, 002))
#define BUTTON_CLICK(e, x) ((e) & NB_MOUSE_MASK(x, 004))
#define BUTTON_DOUBLE_CLICK(e, x) ((e) & NB_MOUSE_MASK(x, 010))
#define BUTTON_TRIPLE_CLICK(e, x) ((e) & NB_MOUSE_MASK(x, 020))
#define BUTTON_RESERVED_EVENT(e, x) ((e) & NB_MOUSE_MASK(x, 040))

typedef unsigned long mmask_t;
typedef struct {
short id; /* ID to distinguish multiple devices */
int x, y, z; /* event coordinates */
mmask_t bstate; /* button state bits */
} MEVENT;

bool has_mouse(void);
int getmouse(MEVENT *);
int ungetmouse(MEVENT *);
mmask_t mousemask(mmask_t, mmask_t *);
bool wenclose(const WINDOW *, int, int);
bool mouse_trafo(int *, int *, bool);
bool wmouse_trafo(const WINDOW *, int *, int *, bool);
int mouseinterval(int);

/* ncurses version for compat */
const char *curses_version(void);

/* Private functions that are needed for user programs prototypes. */
int __cputchar(int);
int __waddbytes(WINDOW *, const char *, int, attr_t);
#ifdef HAVE_WCHAR
int __cputwchar(wchar_t);
#endif /* HAVE_WCHAR */
__END_DECLS

#endif /* !_CURSES_H_ */