ncurses: headers diff between 5.6 and 5.7 versions

	cursesp.h	cursesp.h
	// * This makes emacs happy --Mode: C++;--	// * This makes emacs happy --Mode: C++;--
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2003,2005 Free Software Foundation, Inc. *	* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 37	skipping to change at line 37
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	/************************************************************************	/************************************************************************
	* Author: Juergen Pfeifer, 1997 *	* Author: Juergen Pfeifer, 1997 *
	************************************************************************ /	************************************************************************ /

	#ifndef NCURSES_CURSESP_H_incl	#ifndef NCURSES_CURSESP_H_incl
	#define NCURSES_CURSESP_H_incl 1	#define NCURSES_CURSESP_H_incl 1


	// $Id: cursesp.h,v 1.26 2005/08/13 18:09:21 tom Exp $	// $Id: cursesp.h,v 1.29 2008/08/16 17:20:23 tom Exp $

	#include <ncurses/cursesw.h>	#include <ncurses/cursesw.h>

	extern "C" {	extern "C" {
	# include <ncurses/panel.h>	# include <ncurses/panel.h>
	}	}

	class NCURSES_IMPEXP NCursesPanel	class NCURSES_IMPEXP NCursesPanel
	: public NCursesWindow	: public NCursesWindow
	{	{

	skipping to change at line 74	skipping to change at line 74
	const_cast<void *>(::panel_userptr (p)));	const_cast<void *>(::panel_userptr (p)));
	return uptr;	return uptr;
	}	}

	void init(); // Initialize the panel object	void init(); // Initialize the panel object

	protected:	protected:
	void set_user(void *user)	void set_user(void *user)
	{	{
	UserHook* uptr = UserPointer();	UserHook* uptr = UserPointer();

	assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==p);	if (uptr != 0 && uptr->m_back==this && uptr->m_owner==p) {
	uptr->m_user = user;	uptr->m_user = user;
		}
	}	}
	// Set the user pointer of the panel.	// Set the user pointer of the panel.

	void *get_user()	void *get_user()
	{	{
	UserHook* uptr = UserPointer();	UserHook* uptr = UserPointer();

	assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==p);	void *result = 0;
	return uptr->m_user;	if (uptr != 0 && uptr->m_back==this && uptr->m_owner==p)
		result = uptr->m_user;
		return result;
	}	}


	void OnError (int err) const THROWS((NCursesPanelException))	void OnError (int err) const THROWS(NCursesPanelException)
	{	{
	if (err==ERR)	if (err==ERR)
	THROW(new NCursesPanelException (this, err));	THROW(new NCursesPanelException (this, err));
	}	}
	// If err is equal to the curses error indicator ERR, an error handler	// If err is equal to the curses error indicator ERR, an error handler
	// is called.	// is called.

	// Get a keystroke. Default implementation calls getch()	// Get a keystroke. Default implementation calls getch()
	virtual int getKey(void);	virtual int getKey(void);


End of changes. 5 change blocks.
	7 lines changed or deleted	10 lines changed or added

	cursesw.h	cursesw.h
	// * This makes emacs happy --Mode: C++;--	// * This makes emacs happy --Mode: C++;--

		// vile:cppmode
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2004,2005 Free Software Foundation, Inc. *	* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 33	skipping to change at line 34
	* *	* *
	* Except as contained in this notice, the name(s) of the above copyright *	* Except as contained in this notice, the name(s) of the above copyright *
	* holders shall not be used in advertising or otherwise to promote the *	* holders shall not be used in advertising or otherwise to promote the *
	* sale, use or other dealings in this Software without prior written *	* sale, use or other dealings in this Software without prior written *
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	#ifndef NCURSES_CURSESW_H_incl	#ifndef NCURSES_CURSESW_H_incl
	#define NCURSES_CURSESW_H_incl 1	#define NCURSES_CURSESW_H_incl 1


	// $Id: cursesw.h,v 1.38 2005/07/23 20:51:39 tom Exp $	// $Id: cursesw.h,v 1.48 2008/01/19 21:09:10 tom Exp $

	#include <stdarg.h>
	#include <stdio.h>

	#include <ncurses/etip.h>	#include <ncurses/etip.h>


	#if HAVE_STRSTREAM_H && (USE_STRSTREAM_VSCAN\|\|USE_STRSTREAM_VSCAN_CAST)
	#include <strstream.h>
	#endif

	extern "C" {	extern "C" {
	# include <ncurses/curses.h>	# include <ncurses/curses.h>
	}	}

	/* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.	/* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
	Undefine it here, because NCursesWindow uses lines as a method. */	Undefine it here, because NCursesWindow uses lines as a method. */
	#undef lines	#undef lines

	/* "Convert" macros to inlines. We'll define it as another symbol to avoid	/* "Convert" macros to inlines. We'll define it as another symbol to avoid
	* conflict with library symbols.	* conflict with library symbols.
	*/	*/
	#undef UNDEF	#undef UNDEF
	#define UNDEF(name) CUR_ ##name	#define UNDEF(name) CUR_ ##name

	#ifdef addch	#ifdef addch
	inline int UNDEF(addch)(chtype ch) { return addch(ch); }	inline int UNDEF(addch)(chtype ch) { return addch(ch); }
	#undef addch	#undef addch
	#define addch UNDEF(addch)	#define addch UNDEF(addch)
	#endif	#endif


	#ifdef echochar	#ifdef addchstr
	inline int UNDEF(echochar)(chtype ch) { return echochar(ch); }	inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); }
	#undef echochar	#undef addchstr
	#define echochar UNDEF(echochar)	#define addchstr UNDEF(addchstr)
	#endif	#endif


	#ifdef insdelln	#ifdef addnstr
	inline int UNDEF(insdelln)(int n) { return insdelln(n); }	inline int UNDEF(addnstr)(const char *str, int n)
	#undef insdelln	{ return addnstr(str, n); }
	#define insdelln UNDEF(insdelln)	#undef addnstr
		#define addnstr UNDEF(addnstr)
	#endif	#endif

	#ifdef addstr	#ifdef addstr
	inline int UNDEF(addstr)(const char * str) { return addstr(str); }	inline int UNDEF(addstr)(const char * str) { return addstr(str); }
	#undef addstr	#undef addstr
	#define addstr UNDEF(addstr)	#define addstr UNDEF(addstr)
	#endif	#endif


	#ifdef attron
	inline int UNDEF(attron)(chtype at) { return attron(at); }
	#undef attron
	#define attron UNDEF(attron)
	#endif

	#ifdef attroff	#ifdef attroff
	inline int UNDEF(attroff)(chtype at) { return attroff(at); }	inline int UNDEF(attroff)(chtype at) { return attroff(at); }
	#undef attroff	#undef attroff
	#define attroff UNDEF(attroff)	#define attroff UNDEF(attroff)
	#endif	#endif


		#ifdef attron
		inline int UNDEF(attron)(chtype at) { return attron(at); }
		#undef attron
		#define attron UNDEF(attron)
		#endif

	#ifdef attrset	#ifdef attrset
	inline chtype UNDEF(attrset)(chtype at) { return attrset(at); }	inline chtype UNDEF(attrset)(chtype at) { return attrset(at); }
	#undef attrset	#undef attrset
	#define attrset UNDEF(attrset)	#define attrset UNDEF(attrset)
	#endif	#endif


	#ifdef color_set	#ifdef bkgd
	inline chtype UNDEF(color_set)(short p, void* opts) { return color_set(p, o	inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }
	pts); }	#undef bkgd
	#undef color_set	#define bkgd UNDEF(bkgd)
	#define color_set UNDEF(color_set)	#endif

		#ifdef bkgdset
		inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }
		#undef bkgdset
		#define bkgdset UNDEF(bkgdset)
	#endif	#endif

	#ifdef border	#ifdef border
	inline int UNDEF(border)(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br)	inline int UNDEF(border)(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br)
	{ return border(ls, rs, ts, bs, tl, tr, bl, br); }	{ return border(ls, rs, ts, bs, tl, tr, bl, br); }
	#undef border	#undef border
	#define border UNDEF(border)	#define border UNDEF(border)
	#endif	#endif

	#ifdef box	#ifdef box
	inline int UNDEF(box)(WINDOW *win, int v, int h) { return box(win, v, h); }	inline int UNDEF(box)(WINDOW *win, int v, int h) { return box(win, v, h); }
	#undef box	#undef box
	#define box UNDEF(box)	#define box UNDEF(box)
	#endif	#endif


	#ifdef mvwhline	#ifdef chgat
	inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {	inline int UNDEF(chgat)(int n, attr_t attr, short color, const void *opts)
	return mvwhline(win, y, x, c, n); }	{
	#undef mvwhline	return chgat(n, attr, color, opts); }
	#define mvwhline UNDEF(mvwhline)	#undef chgat
	#endif	#define chgat UNDEF(chgat)

	#ifdef mvwvline
	inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
	return mvwvline(win, y, x, c, n); }
	#undef mvwvline
	#define mvwvline UNDEF(mvwvline)
	#endif	#endif

	#ifdef clear	#ifdef clear
	inline int UNDEF(clear)() { return clear(); }	inline int UNDEF(clear)() { return clear(); }
	#undef clear	#undef clear
	#define clear UNDEF(clear)	#define clear UNDEF(clear)
	#endif	#endif

	#ifdef clearok	#ifdef clearok
	inline int UNDEF(clearok)(WINDOW* win, bool bf) { return clearok(win, bf); }	inline int UNDEF(clearok)(WINDOW* win, bool bf) { return clearok(win, bf); }

	skipping to change at line 159	skipping to change at line 153
	#undef clrtobot	#undef clrtobot
	#define clrtobot UNDEF(clrtobot)	#define clrtobot UNDEF(clrtobot)
	#endif	#endif

	#ifdef clrtoeol	#ifdef clrtoeol
	inline int UNDEF(clrtoeol)() { return clrtoeol(); }	inline int UNDEF(clrtoeol)() { return clrtoeol(); }
	#undef clrtoeol	#undef clrtoeol
	#define clrtoeol UNDEF(clrtoeol)	#define clrtoeol UNDEF(clrtoeol)
	#endif	#endif


		#ifdef color_set
		inline chtype UNDEF(color_set)(short p, void* opts) { return color_set(p, o
		pts); }
		#undef color_set
		#define color_set UNDEF(color_set)
		#endif

		#ifdef crmode
		inline int UNDEF(crmode)(void) { return crmode(); }
		#undef crmode
		#define crmode UNDEF(crmode)
		#endif

	#ifdef delch	#ifdef delch
	inline int UNDEF(delch)() { return delch(); }	inline int UNDEF(delch)() { return delch(); }
	#undef delch	#undef delch
	#define delch UNDEF(delch)	#define delch UNDEF(delch)
	#endif	#endif

	#ifdef deleteln	#ifdef deleteln
	inline int UNDEF(deleteln)() { return deleteln(); }	inline int UNDEF(deleteln)() { return deleteln(); }
	#undef deleteln	#undef deleteln
	#define deleteln UNDEF(deleteln)	#define deleteln UNDEF(deleteln)
	#endif	#endif


		#ifdef echochar
		inline int UNDEF(echochar)(chtype ch) { return echochar(ch); }
		#undef echochar
		#define echochar UNDEF(echochar)
		#endif

	#ifdef erase	#ifdef erase
	inline int UNDEF(erase)() { return erase(); }	inline int UNDEF(erase)() { return erase(); }
	#undef erase	#undef erase
	#define erase UNDEF(erase)	#define erase UNDEF(erase)
	#endif	#endif


		#ifdef fixterm
		inline int UNDEF(fixterm)(void) { return fixterm(); }
		#undef fixterm
		#define fixterm UNDEF(fixterm)
		#endif

	#ifdef flushok	#ifdef flushok
	inline int UNDEF(flushok)(WINDOW* _win, bool _bf) {	inline int UNDEF(flushok)(WINDOW* _win, bool _bf) {
	return flushok(_win, _bf); }	return flushok(_win, _bf); }
	#undef flushok	#undef flushok
	#define flushok UNDEF(flushok)	#define flushok UNDEF(flushok)
	#else	#else
	#define _no_flushok	#define _no_flushok
	#endif	#endif


	#ifdef getch	#ifdef getattrs
	inline int UNDEF(getch)() { return getch(); }	inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); }
	#undef getch	#undef getattrs
	#define getch UNDEF(getch)	#define getattrs UNDEF(getattrs)
	#endif

	#ifdef getstr
	inline int UNDEF(getstr)(char *_str) { return getstr(_str); }
	#undef getstr
	#define getstr UNDEF(getstr)
	#endif

	#ifdef instr
	inline int UNDEF(instr)(char *_str) { return instr(_str); }
	#undef instr
	#define instr UNDEF(instr)
	#endif

	#ifdef innstr
	inline int UNDEF(innstr)(char *_str, int n) { return innstr(_str, n); }
	#undef innstr
	#define innstr UNDEF(innstr)
	#endif

	#ifdef mvwinnstr
	inline int UNDEF(mvwinnstr)(WINDOW win, int y, int x, char _str, int n) {
	return mvwinnstr(win, y, x, _str, n); }
	#undef mvwinnstr
	#define mvwinnstr UNDEF(mvwinnstr)
	#endif

	#ifdef mvinnstr
	inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
	return mvinnstr(y, x, _str, n); }
	#undef mvinnstr
	#define mvinnstr UNDEF(mvinnstr)
	#endif

	#ifdef winsstr
	inline int UNDEF(winsstr)(WINDOW w, const char _str) {
	return winsstr(w, _str); }
	#undef winsstr
	#define winsstr UNDEF(winsstr)
	#endif

	#ifdef mvwinsstr
	inline int UNDEF(mvwinsstr)(WINDOW w, int y, int x, const char _str) {
	return mvwinsstr(w, y, x, _str); }
	#undef mvwinsstr
	#define mvwinsstr UNDEF(mvwinsstr)
	#endif

	#ifdef insstr
	inline int UNDEF(insstr)(const char *_str) {
	return insstr(_str); }
	#undef insstr
	#define insstr UNDEF(insstr)
	#endif	#endif


	#ifdef mvinsstr	#ifdef getbegyx
	inline int UNDEF(mvinsstr)(int y, int x, const char *_str) {	inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y,
	return mvinsstr(y, x, _str); }	x); }
	#undef mvinsstr	#undef getbegyx
	#define mvinsstr UNDEF(mvinsstr)	#define getbegyx UNDEF(getbegyx)
	#endif	#endif


	#ifdef insnstr	#ifdef getbkgd
	inline int UNDEF(insnstr)(const char *_str, int n) {	inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }
	return insnstr(_str, n); }	#undef getbkgd
	#undef insnstr	#define getbkgd UNDEF(getbkgd)
	#define insnstr UNDEF(insnstr)
	#endif	#endif


	#ifdef mvwinsnstr	#ifdef getch
	inline int UNDEF(mvwinsnstr)(WINDOW w, int y, int x, const char _str, int	inline int UNDEF(getch)() { return getch(); }
	n) {	#undef getch
	return mvwinsnstr(w, y, x, _str, n); }	#define getch UNDEF(getch)
	#undef mvwinsnstr
	#define mvwinsnstr UNDEF(mvwinsnstr)
	#endif	#endif


	#ifdef mvinsnstr	#ifdef getmaxyx
	inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {	inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y,
	return mvinsnstr(y, x, _str, n); }	x); }
	#undef mvinsnstr	#undef getmaxyx
	#define mvinsnstr UNDEF(mvinsnstr)	#define getmaxyx UNDEF(getmaxyx)
	#endif	#endif

	#ifdef getnstr	#ifdef getnstr
	inline int UNDEF(getnstr)(char *_str, int n) { return getnstr(_str, n); }	inline int UNDEF(getnstr)(char *_str, int n) { return getnstr(_str, n); }
	#undef getnstr	#undef getnstr
	#define getnstr UNDEF(getnstr)	#define getnstr UNDEF(getnstr)
	#endif	#endif


		#ifdef getparyx
		inline void UNDEF(getparyx)(WINDOW* win, int& y, int& x) { getparyx(win, y,
		x); }
		#undef getparyx
		#define getparyx UNDEF(getparyx)
		#endif

		#ifdef getstr
		inline int UNDEF(getstr)(char *_str) { return getstr(_str); }
		#undef getstr
		#define getstr UNDEF(getstr)
		#endif

	#ifdef getyx	#ifdef getyx
	inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) {	inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) {
	getyx(win, y, x); }	getyx(win, y, x); }
	#undef getyx	#undef getyx
	#define getyx UNDEF(getyx)	#define getyx UNDEF(getyx)
	#endif	#endif


	#ifdef getbegyx
	inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y,
	x); }
	#undef getbegyx
	#define getbegyx UNDEF(getbegyx)
	#endif

	#ifdef getmaxyx
	inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y,
	x); }
	#undef getmaxyx
	#define getmaxyx UNDEF(getmaxyx)
	#endif

	#ifdef hline	#ifdef hline
	inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); }	inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); }
	#undef hline	#undef hline
	#define hline UNDEF(hline)	#define hline UNDEF(hline)
	#endif	#endif

	#ifdef inch	#ifdef inch
	inline chtype UNDEF(inch)() { return inch(); }	inline chtype UNDEF(inch)() { return inch(); }
	#undef inch	#undef inch
	#define inch UNDEF(inch)	#define inch UNDEF(inch)
	#endif	#endif


		#ifdef inchstr
		inline int UNDEF(inchstr)(chtype *str) { return inchstr(str); }
		#undef inchstr
		#define inchstr UNDEF(inchstr)
		#endif

		#ifdef innstr
		inline int UNDEF(innstr)(char *_str, int n) { return innstr(_str, n); }
		#undef innstr
		#define innstr UNDEF(innstr)
		#endif

	#ifdef insch	#ifdef insch
	inline int UNDEF(insch)(chtype c) { return insch(c); }	inline int UNDEF(insch)(chtype c) { return insch(c); }
	#undef insch	#undef insch
	#define insch UNDEF(insch)	#define insch UNDEF(insch)
	#endif	#endif


		#ifdef insdelln
		inline int UNDEF(insdelln)(int n) { return insdelln(n); }
		#undef insdelln
		#define insdelln UNDEF(insdelln)
		#endif

	#ifdef insertln	#ifdef insertln
	inline int UNDEF(insertln)() { return insertln(); }	inline int UNDEF(insertln)() { return insertln(); }
	#undef insertln	#undef insertln
	#define insertln UNDEF(insertln)	#define insertln UNDEF(insertln)
	#endif	#endif


		#ifdef insnstr
		inline int UNDEF(insnstr)(const char *_str, int n) {
		return insnstr(_str, n); }
		#undef insnstr
		#define insnstr UNDEF(insnstr)
		#endif

		#ifdef insstr
		inline int UNDEF(insstr)(const char *_str) {
		return insstr(_str); }
		#undef insstr
		#define insstr UNDEF(insstr)
		#endif

		#ifdef instr
		inline int UNDEF(instr)(char *_str) { return instr(_str); }
		#undef instr
		#define instr UNDEF(instr)
		#endif

		#ifdef intrflush
		inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); }
		#undef intrflush
		#define intrflush UNDEF(intrflush)
		#endif

	#ifdef leaveok	#ifdef leaveok
	inline int UNDEF(leaveok)(WINDOW* win, bool bf) { return leaveok(win, bf); }	inline int UNDEF(leaveok)(WINDOW* win, bool bf) { return leaveok(win, bf); }
	#undef leaveok	#undef leaveok
	#define leaveok UNDEF(leaveok)	#define leaveok UNDEF(leaveok)
	#else	#else
	extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf);	extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf);
	#endif	#endif

	#ifdef move	#ifdef move
	inline int UNDEF(move)(int x, int y) { return move(x, y); }	inline int UNDEF(move)(int x, int y) { return move(x, y); }
	#undef move	#undef move
	#define move UNDEF(move)	#define move UNDEF(move)
	#endif	#endif


	#ifdef refresh	#ifdef mvaddch
	inline int UNDEF(refresh)() { return refresh(); }	inline int UNDEF(mvaddch)(int y, int x, chtype ch)
	#undef refresh	{ return mvaddch(y, x, ch); }
	#define refresh UNDEF(refresh)	#undef mvaddch
	#endif	#define mvaddch UNDEF(mvaddch)

	#ifdef redrawwin
	inline int UNDEF(redrawwin)(WINDOW *win) { return redrawwin(win); }
	#undef redrawwin
	#define redrawwin UNDEF(redrawwin)
	#endif

	#ifdef scrl
	inline int UNDEF(scrl)(int l) { return scrl(l); }
	#undef scrl
	#define scrl UNDEF(scrl)
	#endif

	#ifdef scroll
	inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); }
	#undef scroll
	#define scroll UNDEF(scroll)
	#endif

	#ifdef scrollok
	inline int UNDEF(scrollok)(WINDOW* win, bool bf) { return scrollok(win, bf
	); }
	#undef scrollok
	#define scrollok UNDEF(scrollok)
	#else
	#if defined(__NCURSES_H)
	extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool);
	#else
	extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char);
	#endif
	#endif

	#ifdef setscrreg
	inline int UNDEF(setscrreg)(int t, int b) { return setscrreg(t, b); }
	#undef setscrreg
	#define setscrreg UNDEF(setscrreg)
	#endif

	#ifdef standend
	inline int UNDEF(standend)() { return standend(); }
	#undef standend
	#define standend UNDEF(standend)
	#endif

	#ifdef standout
	inline int UNDEF(standout)() { return standout(); }
	#undef standout
	#define standout UNDEF(standout)
	#endif

	#ifdef subpad
	inline WINDOW UNDEF(subpad)(WINDOW p, int l, int c, int y, int x)
	{ return derwin(p, l, c, y, x); }
	#undef subpad
	#define subpad UNDEF(subpad)
	#endif

	#ifdef timeout
	inline void UNDEF(timeout)(int delay) { timeout(delay); }
	#undef timeout
	#define timeout UNDEF(timeout)
	#endif

	#ifdef touchline
	inline int UNDEF(touchline)(WINDOW *win, int s, int c)
	{ return touchline(win, s, c); }
	#undef touchline
	#define touchline UNDEF(touchline)
	#endif

	#ifdef touchwin
	inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); }
	#undef touchwin
	#define touchwin UNDEF(touchwin)
	#endif	#endif


	#ifdef untouchwin	#ifdef mvaddnstr
	inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); }	inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)
	#undef untouchwin	{ return mvaddnstr(y, x, str, n); }
	#define untouchwin UNDEF(untouchwin)	#undef mvaddnstr
		#define mvaddnstr UNDEF(mvaddnstr)
	#endif	#endif


	#ifdef vline	#ifdef mvaddstr
	inline int UNDEF(vline)(chtype ch, int n) { return vline(ch, n); }	inline int UNDEF(mvaddstr)(int y, int x, const char * str)
	#undef vline	{ return mvaddstr(y, x, str); }
	#define vline UNDEF(vline)	#undef mvaddstr
		#define mvaddstr UNDEF(mvaddstr)
	#endif	#endif


	#ifdef waddstr	#ifdef mvchgat
	inline int UNDEF(waddstr)(WINDOW win, char str) { return waddstr(win, str	inline int UNDEF(mvchgat)(int y, int x, int n,
	); }	attr_t attr, short color, const void *opts) {
	#undef waddstr	return mvchgat(y, x, n, attr, color, opts); }
	#define waddstr UNDEF(waddstr)	#undef mvchgat
		#define mvchgat UNDEF(mvchgat)
	#endif	#endif


	#ifdef waddchstr	#ifdef mvdelch
	inline int UNDEF(waddchstr)(WINDOW win, chtype at) { return waddchstr(win	inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}
	, at); }	#undef mvdelch
	#undef waddchstr	#define mvdelch UNDEF(mvdelch)
	#define waddchstr UNDEF(waddchstr)
	#endif	#endif


	#ifdef wstandend	#ifdef mvgetch
	inline int UNDEF(wstandend)(WINDOW *win) { return wstandend(win); }	inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}
	#undef wstandend	#undef mvgetch
	#define wstandend UNDEF(wstandend)	#define mvgetch UNDEF(mvgetch)
	#endif	#endif


	#ifdef wstandout	#ifdef mvgetnstr
	inline int UNDEF(wstandout)(WINDOW *win) { return wstandout(win); }	inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {
	#undef wstandout	return mvgetnstr(y, x, str, n);}
	#define wstandout UNDEF(wstandout)	#undef mvgetnstr
		#define mvgetnstr UNDEF(mvgetnstr)
	#endif	#endif


	#ifdef wattroff	#ifdef mvgetstr
	inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att	inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x,
	); }	str);}
	#undef wattroff	#undef mvgetstr
	#define wattroff UNDEF(wattroff)	#define mvgetstr UNDEF(mvgetstr)
	#endif	#endif


	#ifdef chgat	#ifdef mvinch
	inline int UNDEF(chgat)(int n, attr_t attr, short color, const void *opts)	inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}
	{	#undef mvinch
	return chgat(n, attr, color, opts); }	#define mvinch UNDEF(mvinch)
	#undef chgat
	#define chgat UNDEF(chgat)
	#endif	#endif


	#ifdef mvchgat	#ifdef mvinnstr
	inline int UNDEF(mvchgat)(int y, int x, int n,	inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
	attr_t attr, short color, const void *opts) {	return mvinnstr(y, x, _str, n); }
	return mvchgat(y, x, n, attr, color, opts); }	#undef mvinnstr
	#undef mvchgat	#define mvinnstr UNDEF(mvinnstr)
	#define mvchgat UNDEF(mvchgat)
	#endif	#endif


	#ifdef mvwchgat	#ifdef mvinsch
	inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,	inline int UNDEF(mvinsch)(int y, int x, chtype c)
	attr_t attr, short color, const void *opts) {	{ return mvinsch(y, x, c); }
	return mvwchgat(win, y, x, n, attr, color, opts); }	#undef mvinsch
	#undef mvwchgat	#define mvinsch UNDEF(mvinsch)
	#define mvwchgat UNDEF(mvwchgat)
	#endif	#endif


	#ifdef wattrset	#ifdef mvinsnstr
	inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att	inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {
	); }	return mvinsnstr(y, x, _str, n); }
	#undef wattrset	#undef mvinsnstr
	#define wattrset UNDEF(wattrset)	#define mvinsnstr UNDEF(mvinsnstr)
	#endif	#endif


	#ifdef winch	#ifdef mvinsstr
	inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); }	inline int UNDEF(mvinsstr)(int y, int x, const char *_str) {
	#undef winch	return mvinsstr(y, x, _str); }
	#define winch UNDEF(winch)	#undef mvinsstr
		#define mvinsstr UNDEF(mvinsstr)
	#endif	#endif

	#ifdef mvwaddch	#ifdef mvwaddch
	inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)	inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)
	{ return mvwaddch(win, y, x, ch); }	{ return mvwaddch(win, y, x, ch); }
	#undef mvwaddch	#undef mvwaddch
	#define mvwaddch UNDEF(mvwaddch)	#define mvwaddch UNDEF(mvwaddch)
	#endif	#endif

	#ifdef mvwaddchnstr	#ifdef mvwaddchnstr

	inline int UNDEF(mvwaddchnstr)(WINDOW win, int y, int x, chtype str, int n)	inline int UNDEF(mvwaddchnstr)(WINDOW win, int y, int x, const chtype str , int n)
	{ return mvwaddchnstr(win, y, x, str, n); }	{ return mvwaddchnstr(win, y, x, str, n); }
	#undef mvwaddchnstr	#undef mvwaddchnstr
	#define mvwaddchnstr UNDEF(mvwaddchnstr)	#define mvwaddchnstr UNDEF(mvwaddchnstr)
	#endif	#endif

	#ifdef mvwaddchstr	#ifdef mvwaddchstr

	inline int UNDEF(mvwaddchstr)(WINDOW win, int y, int x, chtype str)	inline int UNDEF(mvwaddchstr)(WINDOW win, int y, int x, const chtype str)
	{ return mvwaddchstr(win, y, x, str); }	{ return mvwaddchstr(win, y, x, str); }
	#undef mvwaddchstr	#undef mvwaddchstr
	#define mvwaddchstr UNDEF(mvwaddchstr)	#define mvwaddchstr UNDEF(mvwaddchstr)
	#endif	#endif


	#ifdef addnstr
	inline int UNDEF(addnstr)(const char *str, int n)
	{ return addnstr(str, n); }
	#undef addnstr
	#define addnstr UNDEF(addnstr)
	#endif

	#ifdef mvwaddnstr	#ifdef mvwaddnstr
	inline int UNDEF(mvwaddnstr)(WINDOW win, int y, int x, const char str, in t n)	inline int UNDEF(mvwaddnstr)(WINDOW win, int y, int x, const char str, in t n)
	{ return mvwaddnstr(win, y, x, str, n); }	{ return mvwaddnstr(win, y, x, str, n); }
	#undef mvwaddnstr	#undef mvwaddnstr
	#define mvwaddnstr UNDEF(mvwaddnstr)	#define mvwaddnstr UNDEF(mvwaddnstr)
	#endif	#endif

	#ifdef mvwaddstr	#ifdef mvwaddstr
	inline int UNDEF(mvwaddstr)(WINDOW win, int y, int x, const char str)	inline int UNDEF(mvwaddstr)(WINDOW win, int y, int x, const char str)
	{ return mvwaddstr(win, y, x, str); }	{ return mvwaddstr(win, y, x, str); }
	#undef mvwaddstr	#undef mvwaddstr
	#define mvwaddstr UNDEF(mvwaddstr)	#define mvwaddstr UNDEF(mvwaddstr)
	#endif	#endif


		#ifdef mvwchgat
		inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,
		attr_t attr, short color, const void *opts) {
		return mvwchgat(win, y, x, n, attr, color, opts); }
		#undef mvwchgat
		#define mvwchgat UNDEF(mvwchgat)
		#endif

	#ifdef mvwdelch	#ifdef mvwdelch
	inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)	inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)
	{ return mvwdelch(win, y, x); }	{ return mvwdelch(win, y, x); }
	#undef mvwdelch	#undef mvwdelch
	#define mvwdelch UNDEF(mvwdelch)	#define mvwdelch UNDEF(mvwdelch)
	#endif	#endif

	#ifdef mvwgetch	#ifdef mvwgetch
	inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win , y, x);}	inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win , y, x);}
	#undef mvwgetch	#undef mvwgetch
	#define mvwgetch UNDEF(mvwgetch)	#define mvwgetch UNDEF(mvwgetch)
	#endif	#endif


		#ifdef mvwgetnstr
		inline int UNDEF(mvwgetnstr)(WINDOW win, int y, int x, char str, int n)
		{return mvwgetnstr(win, y, x, str, n);}
		#undef mvwgetnstr
		#define mvwgetnstr UNDEF(mvwgetnstr)
		#endif

	#ifdef mvwgetstr	#ifdef mvwgetstr
	inline int UNDEF(mvwgetstr)(WINDOW win, int y, int x, char str)	inline int UNDEF(mvwgetstr)(WINDOW win, int y, int x, char str)
	{return mvwgetstr(win, y, x, str);}	{return mvwgetstr(win, y, x, str);}
	#undef mvwgetstr	#undef mvwgetstr
	#define mvwgetstr UNDEF(mvwgetstr)	#define mvwgetstr UNDEF(mvwgetstr)
	#endif	#endif


	#ifdef mvwgetnstr	#ifdef mvwhline
	inline int UNDEF(mvwgetnstr)(WINDOW win, int y, int x, char str, int n)	inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {
	{return mvwgetnstr(win, y, x, str, n);}	return mvwhline(win, y, x, c, n); }
	#undef mvwgetnstr	#undef mvwhline
	#define mvwgetnstr UNDEF(mvwgetnstr)	#define mvwhline UNDEF(mvwhline)
	#endif	#endif

	#ifdef mvwinch	#ifdef mvwinch
	inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {	inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {
	return mvwinch(win, y, x);}	return mvwinch(win, y, x);}
	#undef mvwinch	#undef mvwinch
	#define mvwinch UNDEF(mvwinch)	#define mvwinch UNDEF(mvwinch)
	#endif	#endif


	#ifdef mvwinsch	#ifdef mvwinchnstr
	inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)	inline int UNDEF(mvwinchnstr)(WINDOW win, int y, int x, chtype str, int n
	{ return mvwinsch(win, y, x, c); }	) { return mvwinchnstr(win, y, x, str, n); }
	#undef mvwinsch	#undef mvwinchnstr
	#define mvwinsch UNDEF(mvwinsch)	#define mvwinchnstr UNDEF(mvwinchnstr)
	#endif	#endif


	#ifdef mvaddch	#ifdef mvwinchstr
	inline int UNDEF(mvaddch)(int y, int x, chtype ch)	inline int UNDEF(mvwinchstr)(WINDOW win, int y, int x, chtype str) { ret
	{ return mvaddch(y, x, ch); }	urn mvwinchstr(win, y, x, str); }
	#undef mvaddch	#undef mvwinchstr
	#define mvaddch UNDEF(mvaddch)	#define mvwinchstr UNDEF(mvwinchstr)
	#endif	#endif


	#ifdef mvaddnstr	#ifdef mvwinnstr
	inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)	inline int UNDEF(mvwinnstr)(WINDOW win, int y, int x, char _str, int n) {
	{ return mvaddnstr(y, x, str, n); }	return mvwinnstr(win, y, x, _str, n); }
	#undef mvaddnstr	#undef mvwinnstr
	#define mvaddnstr UNDEF(mvaddnstr)	#define mvwinnstr UNDEF(mvwinnstr)
	#endif	#endif


	#ifdef mvaddstr	#ifdef mvwinsch
	inline int UNDEF(mvaddstr)(int y, int x, const char * str)	inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)
	{ return mvaddstr(y, x, str); }	{ return mvwinsch(win, y, x, c); }
	#undef mvaddstr	#undef mvwinsch
	#define mvaddstr UNDEF(mvaddstr)	#define mvwinsch UNDEF(mvwinsch)
	#endif	#endif


	#ifdef mvdelch	#ifdef mvwinsnstr
	inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}	inline int UNDEF(mvwinsnstr)(WINDOW w, int y, int x, const char _str, int
	#undef mvdelch	n) {
	#define mvdelch UNDEF(mvdelch)	return mvwinsnstr(w, y, x, _str, n); }
		#undef mvwinsnstr
		#define mvwinsnstr UNDEF(mvwinsnstr)
	#endif	#endif


	#ifdef mvgetch	#ifdef mvwinsstr
	inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}	inline int UNDEF(mvwinsstr)(WINDOW w, int y, int x, const char _str) {
	#undef mvgetch	return mvwinsstr(w, y, x, _str); }
	#define mvgetch UNDEF(mvgetch)	#undef mvwinsstr
		#define mvwinsstr UNDEF(mvwinsstr)
	#endif	#endif


	#ifdef mvgetstr	#ifdef mvwvline
	inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x,	inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
	str);}	return mvwvline(win, y, x, c, n); }
	#undef mvgetstr	#undef mvwvline
	#define mvgetstr UNDEF(mvgetstr)	#define mvwvline UNDEF(mvwvline)
	#endif	#endif


	#ifdef mvgetnstr	#ifdef napms
	inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {	inline void UNDEF(napms)(unsigned long x) { napms(x); }
	return mvgetnstr(y, x, str, n);}	#undef napms
	#undef mvgetnstr	#define napms UNDEF(napms)
	#define mvgetnstr UNDEF(mvgetnstr)
	#endif	#endif


	#ifdef mvinch	#ifdef nocrmode
	inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}	inline int UNDEF(nocrmode)(void) { return nocrmode(); }
	#undef mvinch	#undef nocrmode
	#define mvinch UNDEF(mvinch)	#define nocrmode UNDEF(nocrmode)
	#endif	#endif


	#ifdef mvinsch	#ifdef nodelay
	inline int UNDEF(mvinsch)(int y, int x, chtype c)	inline void UNDEF(nodelay)() { nodelay(); }
	{ return mvinsch(y, x, c); }	#undef nodelay
	#undef mvinsch	#define nodelay UNDEF(nodelay)
	#define mvinsch UNDEF(mvinsch)
	#endif	#endif


	#ifdef napms	#ifdef redrawwin
	inline void UNDEF(napms)(unsigned long x) { napms(x); }	inline int UNDEF(redrawwin)(WINDOW *win) { return redrawwin(win); }
	#undef napms	#undef redrawwin
	#define napms UNDEF(napms)	#define redrawwin UNDEF(redrawwin)
	#endif	#endif


	#ifdef fixterm	#ifdef refresh
	inline int UNDEF(fixterm)(void) { return fixterm(); }	inline int UNDEF(refresh)() { return refresh(); }
	#undef fixterm	#undef refresh
	#define fixterm UNDEF(fixterm)	#define refresh UNDEF(refresh)
	#endif	#endif

	#ifdef resetterm	#ifdef resetterm
	inline int UNDEF(resetterm)(void) { return resetterm(); }	inline int UNDEF(resetterm)(void) { return resetterm(); }
	#undef resetterm	#undef resetterm
	#define resetterm UNDEF(resetterm)	#define resetterm UNDEF(resetterm)
	#endif	#endif

	#ifdef saveterm	#ifdef saveterm
	inline int UNDEF(saveterm)(void) { return saveterm(); }	inline int UNDEF(saveterm)(void) { return saveterm(); }
	#undef saveterm	#undef saveterm
	#define saveterm UNDEF(saveterm)	#define saveterm UNDEF(saveterm)
	#endif	#endif


	#ifdef crmode	#ifdef scrl
	inline int UNDEF(crmode)(void) { return crmode(); }	inline int UNDEF(scrl)(int l) { return scrl(l); }
	#undef crmode	#undef scrl
	#define crmode UNDEF(crmode)	#define scrl UNDEF(scrl)
	#endif	#endif


	#ifdef nocrmode	#ifdef scroll
	inline int UNDEF(nocrmode)(void) { return nocrmode(); }	inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); }
	#undef nocrmode	#undef scroll
	#define nocrmode UNDEF(nocrmode)	#define scroll UNDEF(scroll)
	#endif	#endif


	#ifdef getbkgd	#ifdef scrollok
	inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }	inline int UNDEF(scrollok)(WINDOW* win, bool bf) { return scrollok(win, bf
	#undef getbkgd	); }
	#define getbkgd UNDEF(getbkgd)	#undef scrollok
		#define scrollok UNDEF(scrollok)
		#else
		#if defined(__NCURSES_H)
		extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool);
		#else
		extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char);
		#endif
	#endif	#endif


	#ifdef bkgd	#ifdef setscrreg
	inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }	inline int UNDEF(setscrreg)(int t, int b) { return setscrreg(t, b); }
	#undef bkgd	#undef setscrreg
	#define bkgd UNDEF(bkgd)	#define setscrreg UNDEF(setscrreg)
	#endif	#endif


	#ifdef bkgdset	#ifdef standend
	inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }	inline int UNDEF(standend)() { return standend(); }
	#undef bkgdset	#undef standend
	#define bkgdset UNDEF(bkgdset)	#define standend UNDEF(standend)
		#endif

		#ifdef standout
		inline int UNDEF(standout)() { return standout(); }
		#undef standout
		#define standout UNDEF(standout)
		#endif

		#ifdef subpad
		inline WINDOW UNDEF(subpad)(WINDOW p, int l, int c, int y, int x)
		{ return derwin(p, l, c, y, x); }
		#undef subpad
		#define subpad UNDEF(subpad)
		#endif

		#ifdef timeout
		inline void UNDEF(timeout)(int delay) { timeout(delay); }
		#undef timeout
		#define timeout UNDEF(timeout)
		#endif

		#ifdef touchline
		inline int UNDEF(touchline)(WINDOW *win, int s, int c)
		{ return touchline(win, s, c); }
		#undef touchline
		#define touchline UNDEF(touchline)
		#endif

		#ifdef touchwin
		inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); }
		#undef touchwin
		#define touchwin UNDEF(touchwin)
		#endif

		#ifdef untouchwin
		inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); }
		#undef untouchwin
		#define untouchwin UNDEF(untouchwin)
		#endif

		#ifdef vline
		inline int UNDEF(vline)(chtype ch, int n) { return vline(ch, n); }
		#undef vline
		#define vline UNDEF(vline)
		#endif

		#ifdef waddchstr
		inline int UNDEF(waddchstr)(WINDOW win, chtype at) { return waddchstr(win
		, at); }
		#undef waddchstr
		#define waddchstr UNDEF(waddchstr)
		#endif

		#ifdef waddstr
		inline int UNDEF(waddstr)(WINDOW win, char str) { return waddstr(win, str
		); }
		#undef waddstr
		#define waddstr UNDEF(waddstr)
		#endif

		#ifdef wattroff
		inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att
		); }
		#undef wattroff
		#define wattroff UNDEF(wattroff)
		#endif

		#ifdef wattrset
		inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att
		); }
		#undef wattrset
		#define wattrset UNDEF(wattrset)
		#endif

		#ifdef winch
		inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); }
		#undef winch
		#define winch UNDEF(winch)
		#endif

		#ifdef winchnstr
		inline int UNDEF(winchnstr)(WINDOW win, chtype str, int n) { return winc
		hnstr(win, str, n); }
		#undef winchnstr
		#define winchnstr UNDEF(winchnstr)
		#endif

		#ifdef winchstr
		inline int UNDEF(winchstr)(WINDOW win, chtype str) { return winchstr(win
		, str); }
		#undef winchstr
		#define winchstr UNDEF(winchstr)
		#endif

		#ifdef winsstr
		inline int UNDEF(winsstr)(WINDOW w, const char _str) {
		return winsstr(w, _str); }
		#undef winsstr
		#define winsstr UNDEF(winsstr)
		#endif

		#ifdef wstandend
		inline int UNDEF(wstandend)(WINDOW *win) { return wstandend(win); }
		#undef wstandend
		#define wstandend UNDEF(wstandend)
		#endif

		#ifdef wstandout
		inline int UNDEF(wstandout)(WINDOW *win) { return wstandout(win); }
		#undef wstandout
		#define wstandout UNDEF(wstandout)
	#endif	#endif

	/*	/*
	*	*
	* C++ class for windows.	* C++ class for windows.
	*	*
	*/	*/

	extern "C" int _nc_ripoffline(int, int (init)(WINDOW, int));	extern "C" int _nc_ripoffline(int, int (init)(WINDOW, int));
	extern "C" int _nc_xx_ripoff_init(WINDOW *, int);	extern "C" int _nc_xx_ripoff_init(WINDOW *, int);
	extern "C" int _nc_has_mouse(void);	extern "C" int _nc_has_mouse(void);

	class NCURSES_IMPEXP NCursesWindow	class NCURSES_IMPEXP NCursesWindow
	{	{
	friend class NCursesMenu;	friend class NCursesMenu;
	friend class NCursesForm;	friend class NCursesForm;

	private:	private:
	static bool b_initialized;	static bool b_initialized;
	static void initialize();	static void initialize();

		void constructing();
	friend int _nc_xx_ripoff_init(WINDOW *, int);	friend int _nc_xx_ripoff_init(WINDOW *, int);


	void init();	void set_keyboard();

	short getcolor(int getback) const;	short getcolor(int getback) const;

		short getPair() const;

	static int setpalette(short fore, short back, short pair);	static int setpalette(short fore, short back, short pair);
	static int colorInitialized;	static int colorInitialized;

	// This private constructor is only used during the initialization	// This private constructor is only used during the initialization
	// of windows generated by ripoffline() calls.	// of windows generated by ripoffline() calls.
	NCursesWindow(WINDOW* win, int ncols);	NCursesWindow(WINDOW* win, int ncols);

	protected:	protected:
	virtual void err_handler(const char *) const THROWS(NCursesException);	virtual void err_handler(const char *) const THROWS(NCursesException);

	skipping to change at line 745	skipping to change at line 801
	NCursesWindow* sib; // next subwindow of parent	NCursesWindow* sib; // next subwindow of parent

	void kill_subwindows(); // disable all subwindows	void kill_subwindows(); // disable all subwindows
	// Destroy all subwindows.	// Destroy all subwindows.

	/* Only for use by derived classes. They are then in charge to	/* Only for use by derived classes. They are then in charge to
	fill the member variables correctly. */	fill the member variables correctly. */
	NCursesWindow();	NCursesWindow();

	public:	public:

	NCursesWindow(WINDOW* &window); // useful only for stdscr	NCursesWindow(WINDOW* window); // useful only for stdscr

	NCursesWindow(int nlines, // number of lines	NCursesWindow(int nlines, // number of lines
	int ncols, // number of columns	int ncols, // number of columns
	int begin_y, // line origin	int begin_y, // line origin
	int begin_x); // col origin	int begin_x); // col origin

	NCursesWindow(NCursesWindow& par,// parent window	NCursesWindow(NCursesWindow& par,// parent window
	int nlines, // number of lines	int nlines, // number of lines
	int ncols, // number of columns	int ncols, // number of columns
	int begin_y, // absolute or relative	int begin_y, // absolute or relative

	skipping to change at line 825	skipping to change at line 881

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	// window status	// window status
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	int height() const { return maxy() + 1; }	int height() const { return maxy() + 1; }
	// Number of lines in this window	// Number of lines in this window

	int width() const { return maxx() + 1; }	int width() const { return maxx() + 1; }
	// Number of columns in this window	// Number of columns in this window


	int begx() const { return w->_begx; }	int begx() const { return getbegx(w); }
	// Column of top left corner relative to stdscr	// Column of top left corner relative to stdscr


	int begy() const { return w->_begy; }	int begy() const { return getbegy(w); }
	// Line of top left corner relative to stdscr	// Line of top left corner relative to stdscr


	int maxx() const { return w->_maxx; }	int curx() const { return getcurx(w); }
		// Column of top left corner relative to stdscr

		int cury() const { return getcury(w); }
		// Line of top left corner relative to stdscr

		int maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)
		-1; }
	// Largest x coord in window	// Largest x coord in window


	int maxy() const { return w->_maxy; }	int maxy() const { return getmaxy(w) == ERR ? ERR : getmaxy(w) -1; }
	// Largest y coord in window	// Largest y coord in window

	short getcolor() const;	short getcolor() const;
	// Actual color pair	// Actual color pair

	short foreground() const { return getcolor(0); }	short foreground() const { return getcolor(0); }
	// Actual foreground color	// Actual foreground color

	short background() const { return getcolor(1); }	short background() const { return getcolor(1); }
	// Actual background color	// Actual background color

	skipping to change at line 869	skipping to change at line 931

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	// coordinate positioning	// coordinate positioning
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	int move(int y, int x) { return ::wmove(w, y, x); }	int move(int y, int x) { return ::wmove(w, y, x); }
	// Move cursor the this position	// Move cursor the this position

	void getyx(int& y, int& x) const { ::getyx(w, y, x); }	void getyx(int& y, int& x) const { ::getyx(w, y, x); }
	// Get current position of the cursor	// Get current position of the cursor


		void getbegyx(int& y, int& x) const { ::getbegyx(w, y, x); }
		// Get beginning of the window

		void getmaxyx(int& y, int& x) const { ::getmaxyx(w, y, x); }
		// Get size of the window

		void getparyx(int& y, int& x) const { ::getparyx(w, y, x); }
		// Get parent's beginning of the window

	int mvcur(int oldrow, int oldcol, int newrow, int newcol) cons t {	int mvcur(int oldrow, int oldcol, int newrow, int newcol) cons t {
	return ::mvcur(oldrow, oldcol, newrow, newcol); }	return ::mvcur(oldrow, oldcol, newrow, newcol); }
	// Perform lowlevel cursor motion that takes effect immediately.	// Perform lowlevel cursor motion that takes effect immediately.

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	// input	// input
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	int getch() { return ::wgetch(w); }	int getch() { return ::wgetch(w); }
	// Get a keystroke from the window.	// Get a keystroke from the window.


	skipping to change at line 911	skipping to change at line 982
	// as described above.	// as described above.

	int scanw(const char* fmt, ...)	int scanw(const char* fmt, ...)
	// Perform a scanw function from the window.	// Perform a scanw function from the window.
	#if __GNUG__ >= 2	#if __GNUG__ >= 2
	__attribute__ ((format (scanf, 2, 3)));	__attribute__ ((format (scanf, 2, 3)));
	#else	#else
	;	;
	#endif	#endif


		int scanw(const char*, va_list);
		// Perform a scanw function from the window.

	int scanw(int y, int x, const char* fmt, ...)	int scanw(int y, int x, const char* fmt, ...)
	// Move the cursor to the requested position and then perform a scanw	// Move the cursor to the requested position and then perform a scanw
	// from the window.	// from the window.
	#if __GNUG__ >= 2	#if __GNUG__ >= 2
	__attribute__ ((format (scanf, 4, 5)));	__attribute__ ((format (scanf, 4, 5)));
	#else	#else
	;	;
	#endif	#endif


		int scanw(int y, int x, const char* fmt, va_list);
		// Move the cursor to the requested position and then perform a scanw
		// from the window.

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	// output	// output
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	int addch(const chtype ch) { return ::waddch(w, ch); }	int addch(const chtype ch) { return ::waddch(w, ch); }
	// Put attributed character to the window.	// Put attributed character to the window.

	int addch(int y, int x, const chtype ch) {	int addch(int y, int x, const chtype ch) {
	return ::mvwaddch(w, y, x, ch); }	return ::mvwaddch(w, y, x, ch); }
	// Move cursor to the requested position and then put attributed characte r	// Move cursor to the requested position and then put attributed characte r
	// to the window.	// to the window.

	skipping to change at line 941	skipping to change at line 1019
	int echochar(const chtype ch) { return ::wechochar(w, ch); }	int echochar(const chtype ch) { return ::wechochar(w, ch); }
	// Put attributed character to the window and refresh it immediately.	// Put attributed character to the window and refresh it immediately.

	int addstr(const char* str, int n=-1) {	int addstr(const char* str, int n=-1) {
	return ::waddnstr(w, str, n); }	return ::waddnstr(w, str, n); }
	// Write the string str to the window, stop writing if the terminating	// Write the string str to the window, stop writing if the terminating
	// NUL or the limit n is reached. If n is negative, it is ignored.	// NUL or the limit n is reached. If n is negative, it is ignored.

	int addstr(int y, int x, const char * str, int n=-1) {	int addstr(int y, int x, const char * str, int n=-1) {
	return ::mvwaddnstr(w, y, x, str, n); }	return ::mvwaddnstr(w, y, x, str, n); }

	// Move the cursor to the requested position and then perform the addstr	// Move the cursor to the requested position and then perform the addchst
		r
		// as described above.

		int addchstr(const chtype* str, int n=-1) {
		return ::waddchnstr(w, str, n); }
		// Write the string str to the window, stop writing if the terminating
		// NUL or the limit n is reached. If n is negative, it is ignored.

		int addchstr(int y, int x, const chtype * str, int n=-1) {
		return ::mvwaddchnstr(w, y, x, str, n); }
		// Move the cursor to the requested position and then perform the addchst
		r
	// as described above.	// as described above.

	int printw(const char* fmt, ...)	int printw(const char* fmt, ...)
	// Do a formatted print to the window.	// Do a formatted print to the window.
	#if (__GNUG__ >= 2) && !defined(printf)	#if (__GNUG__ >= 2) && !defined(printf)
	__attribute__ ((format (printf, 2, 3)));	__attribute__ ((format (printf, 2, 3)));
	#else	#else
	;	;
	#endif	#endif

	int printw(int y, int x, const char * fmt, ...)	int printw(int y, int x, const char * fmt, ...)
	// Move the cursor and then do a formatted print to the window.	// Move the cursor and then do a formatted print to the window.
	#if (__GNUG__ >= 2) && !defined(printf)	#if (__GNUG__ >= 2) && !defined(printf)
	__attribute__ ((format (printf, 4, 5)));	__attribute__ ((format (printf, 4, 5)));
	#else	#else
	;	;
	#endif	#endif


		int printw(const char* fmt, va_list args);
		// Do a formatted print to the window.

		int printw(int y, int x, const char * fmt, va_list args);
		// Move the cursor and then do a formatted print to the window.

	chtype inch() const { return ::winch(w); }	chtype inch() const { return ::winch(w); }
	// Retrieve attributed character under the current cursor position.	// Retrieve attributed character under the current cursor position.

	chtype inch(int y, int x) { return ::mvwinch(w, y, x); }	chtype inch(int y, int x) { return ::mvwinch(w, y, x); }
	// Move cursor to requested position and then retrieve attributed charact er	// Move cursor to requested position and then retrieve attributed charact er
	// at this position.	// at this position.


		int inchstr(chtype* str, int n=-1) {
		return ::winchnstr(w, str, n); }
		// Read the string str from the window, stop reading if the terminating
		// NUL or the limit n is reached. If n is negative, it is ignored.

		int inchstr(int y, int x, chtype * str, int n=-1) {
		return ::mvwinchnstr(w, y, x, str, n); }
		// Move the cursor to the requested position and then perform the inchstr
		// as described above.

	int insch(chtype ch) { return ::winsch(w, ch); }	int insch(chtype ch) { return ::winsch(w, ch); }
	// Insert attributed character into the window before current cursor	// Insert attributed character into the window before current cursor
	// position.	// position.

	int insch(int y, int x, chtype ch) {	int insch(int y, int x, chtype ch) {
	return ::mvwinsch(w, y, x, ch); }	return ::mvwinsch(w, y, x, ch); }
	// Move cursor to requested position and then insert the attributed	// Move cursor to requested position and then insert the attributed
	// character before that position.	// character before that position.

	int insertln() { return ::winsdelln(w, 1); }	int insertln() { return ::winsdelln(w, 1); }

	skipping to change at line 1003	skipping to change at line 1107

	int attron (chtype at) { return ::wattron (w, at); }	int attron (chtype at) { return ::wattron (w, at); }
	// Switch on the window attributes;	// Switch on the window attributes;

	int attroff(chtype at) { return ::wattroff(w, static_cast<int> (at)); }	int attroff(chtype at) { return ::wattroff(w, static_cast<int> (at)); }
	// Switch off the window attributes;	// Switch off the window attributes;

	int attrset(chtype at) { return ::wattrset(w, static_cast<int> (at)); }	int attrset(chtype at) { return ::wattrset(w, static_cast<int> (at)); }
	// Set the window attributes;	// Set the window attributes;


		chtype attrget() { return ::getattrs(w); }
		// Get the window attributes;

	int color_set(short color_pair_number, void* opts=NULL) {	int color_set(short color_pair_number, void* opts=NULL) {
	return ::wcolor_set(w, color_pair_number, opts); }	return ::wcolor_set(w, color_pair_number, opts); }
	// Set the window color attribute;	// Set the window color attribute;

	int chgat(int n, attr_t attr, short color, const void *opts=NU LL) {	int chgat(int n, attr_t attr, short color, const void *opts=NU LL) {
	return ::wchgat(w, n, attr, color, opts); }	return ::wchgat(w, n, attr, color, opts); }
	// Change the attributes of the next n characters in the current line. If	// Change the attributes of the next n characters in the current line. If
	// n is negative or greater than the number of remaining characters in th e	// n is negative or greater than the number of remaining characters in th e
	// line, the attributes will be changed up to the end of the line.	// line, the attributes will be changed up to the end of the line.


	skipping to change at line 1122	skipping to change at line 1229
	// Define a soft scrolling region.	// Define a soft scrolling region.

	int idlok(bool bf) { return ::idlok(w, bf); }	int idlok(bool bf) { return ::idlok(w, bf); }
	// If bf is TRUE, use insert/delete line hardware support if possible.	// If bf is TRUE, use insert/delete line hardware support if possible.
	// Otherwise do it in software.	// Otherwise do it in software.

	void idcok(bool bf) { ::idcok(w, bf); }	void idcok(bool bf) { ::idcok(w, bf); }
	// If bf is TRUE, use insert/delete character hardware support if possibl e.	// If bf is TRUE, use insert/delete character hardware support if possibl e.
	// Otherwise do it in software.	// Otherwise do it in software.


		int touchline(int s, int c) { return ::touchline(w, s, c); }
		// Mark the given lines as modified.

	int touchwin() { return ::wtouchln(w, 0, height(), 1); }	int touchwin() { return ::wtouchln(w, 0, height(), 1); }
	// Mark the whole window as modified.	// Mark the whole window as modified.

	int untouchwin() { return ::wtouchln(w, 0, height(), 0); }	int untouchwin() { return ::wtouchln(w, 0, height(), 0); }
	// Mark the whole window as unmodified.	// Mark the whole window as unmodified.

	int touchln(int s, int cnt, bool changed=TRUE) {	int touchln(int s, int cnt, bool changed=TRUE) {
	return ::wtouchln(w, s, cnt, static_cast<int>(changed ? 1 : 0)); }	return ::wtouchln(w, s, cnt, static_cast<int>(changed ? 1 : 0)); }
	// Mark cnt lines beginning from line s as changed or unchanged, dependin g	// Mark cnt lines beginning from line s as changed or unchanged, dependin g
	// on the value of the changed flag.	// on the value of the changed flag.

	skipping to change at line 1174	skipping to change at line 1284
	// If called with bf=TRUE, syncup() is called whenever the window is chan ged	// If called with bf=TRUE, syncup() is called whenever the window is chan ged

	#ifndef _no_flushok	#ifndef _no_flushok
	int flushok(bool bf) { return ::flushok(w, bf); }	int flushok(bool bf) { return ::flushok(w, bf); }
	#endif	#endif

	void immedok(bool bf) { ::immedok(w, bf); }	void immedok(bool bf) { ::immedok(w, bf); }
	// If called with bf=TRUE, any change in the window will cause an	// If called with bf=TRUE, any change in the window will cause an
	// automatic immediate refresh()	// automatic immediate refresh()


		int intrflush(bool bf) { return ::intrflush(w, bf); }

	int keypad(bool bf) { return ::keypad(w, bf); }	int keypad(bool bf) { return ::keypad(w, bf); }
	// If called with bf=TRUE, the application will interpret function keys.	// If called with bf=TRUE, the application will interpret function keys.


		int nodelay(bool bf) { return ::nodelay(w, bf); }

	int meta(bool bf) { return ::meta(w, bf); }	int meta(bool bf) { return ::meta(w, bf); }
	// If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise	// If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise
	// 7-Bit characters are generated.	// 7-Bit characters are generated.

	int standout() { return ::wstandout(w); }	int standout() { return ::wstandout(w); }
	// Enable "standout" attributes	// Enable "standout" attributes

	int standend() { return ::wstandend(w); }	int standend() { return ::wstandend(w); }
	// Disable "standout" attributes	// Disable "standout" attributes


	skipping to change at line 1221	skipping to change at line 1335
	int sminrow, int smincol,	int sminrow, int smincol,
	int dminrow, int dmincol,	int dminrow, int dmincol,
	int dmaxrow, int dmaxcol, bool overlaywin=TRUE) {	int dmaxrow, int dmaxcol, bool overlaywin=TRUE) {
	return ::copywin(w, win.w, sminrow, smincol, dminrow, dmincol,	return ::copywin(w, win.w, sminrow, smincol, dminrow, dmincol,
	dmaxrow, dmaxcol, static_cast<int>(overlaywin ? 1 : 0)) ; }	dmaxrow, dmaxcol, static_cast<int>(overlaywin ? 1 : 0)) ; }
	// Overlay or overwrite the rectangle in win given by dminrow,dmincol,	// Overlay or overwrite the rectangle in win given by dminrow,dmincol,
	// dmaxrow,dmaxcol with the rectangle in this window beginning at	// dmaxrow,dmaxcol with the rectangle in this window beginning at
	// sminrow,smincol.	// sminrow,smincol.

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---

		// Extended functions
		// ----------------------------------------------------------------------
		---
		#if defined(NCURSES_EXT_FUNCS) && (NCURSES_EXT_FUNCS != 0)
		int wresize(int newLines, int newColumns) {
		return ::wresize(w, newLines, newColumns); }
		#endif

		// ----------------------------------------------------------------------
		---
	// Mouse related	// Mouse related
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	bool has_mouse() const;	bool has_mouse() const;
	// Return TRUE if terminal supports a mouse, FALSE otherwise	// Return TRUE if terminal supports a mouse, FALSE otherwise

	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	// traversal support	// traversal support
	// ---------------------------------------------------------------------- ---	// ---------------------------------------------------------------------- ---
	NCursesWindow* child() { return subwins; }	NCursesWindow* child() { return subwins; }
	// Get the first child window.	// Get the first child window.

End of changes. 78 change blocks.
	365 lines changed or deleted	497 lines changed or added

	etip.h	etip.h
	// * This makes emacs happy --Mode: C++;--	// * This makes emacs happy --Mode: C++;--
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2003,2005 Free Software Foundation, Inc. *	* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 34	skipping to change at line 34
	* Except as contained in this notice, the name(s) of the above copyright *	* Except as contained in this notice, the name(s) of the above copyright *
	* holders shall not be used in advertising or otherwise to promote the *	* holders shall not be used in advertising or otherwise to promote the *
	* sale, use or other dealings in this Software without prior written *	* sale, use or other dealings in this Software without prior written *
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	/************************************************************************	/************************************************************************
	* Author: Juergen Pfeifer, 1997 *	* Author: Juergen Pfeifer, 1997 *
	************************************************************************ /	************************************************************************ /


	// $Id: etip.h.in,v 1.32 2005/08/06 19:55:57 tom Exp $	// $Id: etip.h.in,v 1.37 2008/08/30 19:27:32 tom Exp $

	#ifndef NCURSES_ETIP_H_incl	#ifndef NCURSES_ETIP_H_incl
	#define NCURSES_ETIP_H_incl 1	#define NCURSES_ETIP_H_incl 1

	// These are substituted at configure/build time	// These are substituted at configure/build time
	#ifndef HAVE_BUILTIN_H	#ifndef HAVE_BUILTIN_H
	#define HAVE_BUILTIN_H 0	#define HAVE_BUILTIN_H 0
	#endif	#endif

	#ifndef HAVE_GXX_BUILTIN_H	#ifndef HAVE_GXX_BUILTIN_H
	#define HAVE_GXX_BUILTIN_H 0	#define HAVE_GXX_BUILTIN_H 0
	#endif	#endif

	#ifndef HAVE_GPP_BUILTIN_H	#ifndef HAVE_GPP_BUILTIN_H
	#define HAVE_GPP_BUILTIN_H 0	#define HAVE_GPP_BUILTIN_H 0
	#endif	#endif


	#ifndef HAVE_STRSTREAM_H	#ifndef HAVE_IOSTREAM
	#define HAVE_STRSTREAM_H 0	#define HAVE_IOSTREAM 1
	#endif	#endif

	#ifndef HAVE_TYPEINFO	#ifndef HAVE_TYPEINFO
	#define HAVE_TYPEINFO 1	#define HAVE_TYPEINFO 1
	#endif	#endif

	#ifndef HAVE_VALUES_H	#ifndef HAVE_VALUES_H
	#define HAVE_VALUES_H 0	#define HAVE_VALUES_H 0
	#endif	#endif


	skipping to change at line 80	skipping to change at line 80
	#endif	#endif

	#ifndef CPP_HAS_PARAM_INIT	#ifndef CPP_HAS_PARAM_INIT
	#define CPP_HAS_PARAM_INIT 0	#define CPP_HAS_PARAM_INIT 0
	#endif	#endif

	#ifndef CPP_HAS_STATIC_CAST	#ifndef CPP_HAS_STATIC_CAST
	#define CPP_HAS_STATIC_CAST 1	#define CPP_HAS_STATIC_CAST 1
	#endif	#endif


	#ifndef USE_STRSTREAM_VSCAN	#ifndef IOSTREAM_NAMESPACE
	#define USE_STRSTREAM_VSCAN 0	#define IOSTREAM_NAMESPACE 1
	#endif

	#ifndef USE_STRSTREAM_VSCAN_CAST
	#define USE_STRSTREAM_VSCAN 0
	#endif	#endif

	#ifdef __GNUG__	#ifdef __GNUG__
	# if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))	# if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))
	# if HAVE_TYPEINFO	# if HAVE_TYPEINFO
	# include <typeinfo>	# include <typeinfo>
	# endif	# endif
	# endif	# endif
	#endif	#endif


	skipping to change at line 338	skipping to change at line 334
	virtual const char *classname() const {	virtual const char *classname() const {
	return "NCursesForm";	return "NCursesForm";
	}	}

	virtual ~NCursesFormException()	virtual ~NCursesFormException()
	{	{
	}	}
	};	};

	#if !((defined(__GNUG__) && defined(__EXCEPTIONS)) \|\| defined(__SUNPRO_CC))	#if !((defined(__GNUG__) && defined(__EXCEPTIONS)) \|\| defined(__SUNPRO_CC))

	# include <iostream.h>	# if HAVE_IOSTREAM
		# include <iostream>
		# if IOSTREAM_NAMESPACE
		using std::cerr;
		using std::endl;
		# endif
		# else
		# include <iostream.h>
		# endif
	extern "C" void exit(int);	extern "C" void exit(int);
	#endif	#endif

	inline void THROW(const NCursesException *e) {	inline void THROW(const NCursesException *e) {
	#if defined(__GNUG__) && defined(__EXCEPTIONS)	#if defined(__GNUG__) && defined(__EXCEPTIONS)
	# if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))	# if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))

	(*lib_error_handler)(e?e->classname():"",e?e->message:"");	(*lib_error_handler)(e ? e->classname() : "", e ? e->message : "");
	#else	#else

	throw *e;	#define CPP_HAS_TRY_CATCH 1
	#endif	#endif
	#elif defined(__SUNPRO_CC)	#elif defined(__SUNPRO_CC)
	# if !defined(__SUNPRO_CC_COMPAT) \|\| (__SUNPRO_CC_COMPAT < 5)	# if !defined(__SUNPRO_CC_COMPAT) \|\| (__SUNPRO_CC_COMPAT < 5)
	genericerror(1, ((e != 0) ? (char *)(e->message) : ""));	genericerror(1, ((e != 0) ? (char *)(e->message) : ""));
	#else	#else

	throw *e;	#define CPP_HAS_TRY_CATCH 1
	#endif	#endif
	#else	#else
	if (e)	if (e)
	cerr << e->message << endl;	cerr << e->message << endl;
	exit(0);	exit(0);
	#endif	#endif

	}


	#define THROWS(s)	#ifndef CPP_HAS_TRY_CATCH
		#define CPP_HAS_TRY_CATCH 0
		#define NCURSES_CPP_TRY /* nothing */
		#define NCURSES_CPP_CATCH(e) if (false)
		#define THROWS(s) /* nothing */
		#elif CPP_HAS_TRY_CATCH
		throw *e;
		#define NCURSES_CPP_TRY try
		#define NCURSES_CPP_CATCH(e) catch(e)
		#define THROWS(s) throw(s)
		#endif
		}

	#endif /* NCURSES_ETIP_H_incl */	#endif /* NCURSES_ETIP_H_incl */

End of changes. 10 change blocks.
	16 lines changed or deleted	30 lines changed or added

	ncurses_dll.h	ncurses_dll.h
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2004,2005 Free Software Foundation, Inc. *	* Copyright (c) 1998-2006,2007 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 28	skipping to change at line 28
	* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *	* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
	* THE USE OR OTHER DEALINGS IN THE SOFTWARE. *	* THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
	* *	* *
	* Except as contained in this notice, the name(s) of the above copyright *	* Except as contained in this notice, the name(s) of the above copyright *
	* holders shall not be used in advertising or otherwise to promote the *	* holders shall not be used in advertising or otherwise to promote the *
	* sale, use or other dealings in this Software without prior written *	* sale, use or other dealings in this Software without prior written *
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	/* $Id: ncurses_dll.h,v 1.5 2006/04/22 22:07:51 tom Exp $ */	/* $Id: ncurses_dll.h,v 1.6 2007/03/10 19:21:49 tom Exp $ */

	#ifndef NCURSES_DLL_H_incl	#ifndef NCURSES_DLL_H_incl
	#define NCURSES_DLL_H_incl 1	#define NCURSES_DLL_H_incl 1

	/* no longer needed on cygwin or mingw, thanks to auto-import */	/* no longer needed on cygwin or mingw, thanks to auto-import */
	/* but this structure may be useful at some point for an MSVC build */	/* but this structure may be useful at some point for an MSVC build */
	/* so, for now unconditionally define the important flags */	/* so, for now unconditionally define the important flags */
	/* "the right way" for proper static and dll+auto-import behavior */	/* "the right way" for proper static and dll+auto-import behavior */
	#undef NCURSES_DLL	#undef NCURSES_DLL
	#define NCURSES_STATIC	#define NCURSES_STATIC

	skipping to change at line 79	skipping to change at line 79
	#if !defined(NCURSES_API)	#if !defined(NCURSES_API)
	# define NCURSES_API /* nothing */	# define NCURSES_API /* nothing */
	#endif	#endif
	#if !defined(NCURSES_EXPORT)	#if !defined(NCURSES_EXPORT)
	# define NCURSES_EXPORT(type) NCURSES_IMPEXP type NCURSES_API	# define NCURSES_EXPORT(type) NCURSES_IMPEXP type NCURSES_API
	#endif	#endif
	#if !defined(NCURSES_EXPORT_VAR)	#if !defined(NCURSES_EXPORT_VAR)
	# define NCURSES_EXPORT_VAR(type) NCURSES_IMPEXP type	# define NCURSES_EXPORT_VAR(type) NCURSES_IMPEXP type
	#endif	#endif


		/*
		* For reentrant code, we map the various global variables into SCREEN by
		* using functions to access them.
		*/
		#define NCURSES_PUBLIC_VAR(name) _nc_##name
		#define NCURSES_WRAPPED_VAR(type,name) extern type NCURSES_PUBLIC_VAR(name)
		(void)

	#endif /* NCURSES_DLL_H_incl */	#endif /* NCURSES_DLL_H_incl */

End of changes. 3 change blocks.
	2 lines changed or deleted	10 lines changed or added

	term.h	term.h
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2003,2006 Free Software Foundation, Inc. *	* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 35	skipping to change at line 35
	* sale, use or other dealings in this Software without prior written *	* sale, use or other dealings in this Software without prior written *
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	/************************************************************************ /	/************************************************************************ /
	/* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 */	/* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 */
	/* and: Eric S. Raymond <esr@snark.thyrsus.com> */	/* and: Eric S. Raymond <esr@snark.thyrsus.com> */
	/* and: Thomas E. Dickey 1995-on */	/* and: Thomas E. Dickey 1995-on */
	/************************************************************************ /	/************************************************************************ /


	/* $Id: MKterm.h.awk.in,v 1.47 2006/11/26 01:18:23 tom Exp $ */	/* $Id: MKterm.h.awk.in,v 1.50 2008/05/24 23:13:59 tom Exp $ */

	/*	/*
	** term.h -- Definition of struct term	** term.h -- Definition of struct term
	*/	*/

	#ifndef NCURSES_TERM_H_incl	#ifndef NCURSES_TERM_H_incl
	#define NCURSES_TERM_H_incl 1	#define NCURSES_TERM_H_incl 1

	#undef NCURSES_VERSION	#undef NCURSES_VERSION

	#define NCURSES_VERSION "5.6"	#define NCURSES_VERSION "5.7"

	#include <ncurses/ncurses_dll.h>	#include <ncurses/ncurses_dll.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	/* Make this file self-contained by providing defaults for the HAVE_TERMIO[ S]_H	/* Make this file self-contained by providing defaults for the HAVE_TERMIO[ S]_H
	* definition (based on the system for which this was configured).	* definition (based on the system for which this was configured).
	*/	*/

	skipping to change at line 703	skipping to change at line 703

	typedef struct term { /* describe an actual terminal */	typedef struct term { /* describe an actual terminal */
	TERMTYPE type; /* terminal type description */	TERMTYPE type; /* terminal type description */
	short Filedes; /* file description being written to */	short Filedes; /* file description being written to */
	TTY Ottyb, /* original state of the terminal */	TTY Ottyb, /* original state of the terminal */
	Nttyb; /* current state of the terminal */	Nttyb; /* current state of the terminal */
	int _baudrate; /* used to compute padding */	int _baudrate; /* used to compute padding */
	char * _termname; /* used for termname() */	char * _termname; /* used for termname() */
	} TERMINAL;	} TERMINAL;


	extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;	#if 0 \|\| 0
		NCURSES_WRAPPED_VAR(TERMINAL *, cur_term);
	#if 0 /* BROKEN_LINKER */	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolnames);
	#define boolnames _nc_boolnames()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolcodes);
	#define boolcodes _nc_boolcodes()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolfnames);
	#define boolfnames _nc_boolfnames()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numnames);
	#define numnames _nc_numnames()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numcodes);
	#define numcodes _nc_numcodes()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numfnames);
	#define numfnames _nc_numfnames()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strnames);
	#define strnames _nc_strnames()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strcodes);
	#define strcodes _nc_strcodes()	NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strfnames);
	#define strfnames _nc_strfnames()


	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_boolnames (void);	#define cur_term NCURSES_PUBLIC_VAR(cur_term())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_boolcodes (void);	#define boolnames NCURSES_PUBLIC_VAR(boolnames())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_boolfnames (void);	#define boolcodes NCURSES_PUBLIC_VAR(boolcodes())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_numnames (void);	#define boolfnames NCURSES_PUBLIC_VAR(boolfnames())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_numcodes (void);	#define numnames NCURSES_PUBLIC_VAR(numnames())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_numfnames (void);	#define numcodes NCURSES_PUBLIC_VAR(numcodes())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_strnames (void);	#define numfnames NCURSES_PUBLIC_VAR(numfnames())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_strcodes (void);	#define strnames NCURSES_PUBLIC_VAR(strnames())
	extern NCURSES_EXPORT(NCURSES_CONST char * const *) _nc_strfnames (void);	#define strcodes NCURSES_PUBLIC_VAR(strcodes())
		#define strfnames NCURSES_PUBLIC_VAR(strfnames())

	#else	#else


		extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;

	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolnames[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolcodes[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolcodes[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolfnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolfnames[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numnames[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numcodes[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numcodes[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numfnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numfnames[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strnames[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strcodes[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strcodes[];
	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strfnames[];	extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strfnames[];


	skipping to change at line 767	skipping to change at line 769

	/* terminfo entry points, also declared in curses.h */	/* terminfo entry points, also declared in curses.h */
	#if !defined(__NCURSES_H)	#if !defined(__NCURSES_H)
	extern NCURSES_EXPORT(char ) tigetstr (NCURSES_CONST char );	extern NCURSES_EXPORT(char ) tigetstr (NCURSES_CONST char );
	extern NCURSES_EXPORT_VAR(char) ttytype[];	extern NCURSES_EXPORT_VAR(char) ttytype[];
	extern NCURSES_EXPORT(int) putp (const char *);	extern NCURSES_EXPORT(int) putp (const char *);
	extern NCURSES_EXPORT(int) tigetflag (NCURSES_CONST char *);	extern NCURSES_EXPORT(int) tigetflag (NCURSES_CONST char *);
	extern NCURSES_EXPORT(int) tigetnum (NCURSES_CONST char *);	extern NCURSES_EXPORT(int) tigetnum (NCURSES_CONST char *);

	#if 1 /* NCURSES_TPARM_VARARGS */	#if 1 /* NCURSES_TPARM_VARARGS */

	extern NCURSES_EXPORT(char ) tparm (NCURSES_CONST char , ...); /* i mplemented */	extern NCURSES_EXPORT(char ) tparm (NCURSES_CONST char , ...); /* s pecial */
	#else	#else

	extern NCURSES_EXPORT(char ) tparm (NCURSES_CONST char , long,long,long,l	extern NCURSES_EXPORT(char ) tparm (NCURSES_CONST char , long,long,long,l
	ong,long,long,long,long,long); /* implemented */	ong,long,long,long,long,long); /* special */
	extern NCURSES_EXPORT(char ) tparm_varargs (NCURSES_CONST char , ...);	extern NCURSES_EXPORT(char ) tparm_varargs (NCURSES_CONST char , ...);
	/* implemented */	/* special */
	#endif	#endif

	#endif /* __NCURSES_H */	#endif /* __NCURSES_H */

	/* termcap database emulation (XPG4 uses const only for 2nd param of tgeten t) */	/* termcap database emulation (XPG4 uses const only for 2nd param of tgeten t) */
	#if !defined(NCURSES_TERMCAP_H_incl)	#if !defined(NCURSES_TERMCAP_H_incl)
	extern NCURSES_EXPORT(char ) tgetstr (NCURSES_CONST char , char **);	extern NCURSES_EXPORT(char ) tgetstr (NCURSES_CONST char , char **);
	extern NCURSES_EXPORT(char ) tgoto (const char , int, int);	extern NCURSES_EXPORT(char ) tgoto (const char , int, int);
	extern NCURSES_EXPORT(int) tgetent (char , const char );	extern NCURSES_EXPORT(int) tgetent (char , const char );
	extern NCURSES_EXPORT(int) tgetflag (NCURSES_CONST char *);	extern NCURSES_EXPORT(int) tgetflag (NCURSES_CONST char *);

End of changes. 8 change blocks.
	29 lines changed or deleted	31 lines changed or added

	termcap.h	termcap.h

	skipping to change at line 40	skipping to change at line 40
	* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *	* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
	* and: Eric S. Raymond <esr@snark.thyrsus.com> *	* and: Eric S. Raymond <esr@snark.thyrsus.com> *
	************************************************************************ /	************************************************************************ /

	/* $Id: termcap.h.in,v 1.16 2001/03/24 21:53:27 tom Exp $ */	/* $Id: termcap.h.in,v 1.16 2001/03/24 21:53:27 tom Exp $ */

	#ifndef NCURSES_TERMCAP_H_incl	#ifndef NCURSES_TERMCAP_H_incl
	#define NCURSES_TERMCAP_H_incl 1	#define NCURSES_TERMCAP_H_incl 1

	#undef NCURSES_VERSION	#undef NCURSES_VERSION

	#define NCURSES_VERSION "5.6"	#define NCURSES_VERSION "5.7"

	#include <ncurses/ncurses_dll.h>	#include <ncurses/ncurses_dll.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C"	extern "C"
	{	{
	#endif /* __cplusplus */	#endif /* __cplusplus */

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


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	unctrl.h	unctrl.h

	skipping to change at line 48	skipping to change at line 48
	* Control characters are displayed in caret notation (^x), DELETE is displ ayed	* Control characters are displayed in caret notation (^x), DELETE is displ ayed
	* as ^?. Printable characters are displayed as is.	* as ^?. Printable characters are displayed as is.
	*/	*/

	/* $Id: unctrl.h.in,v 1.10 2001/03/24 21:53:25 tom Exp $ */	/* $Id: unctrl.h.in,v 1.10 2001/03/24 21:53:25 tom Exp $ */

	#ifndef NCURSES_UNCTRL_H_incl	#ifndef NCURSES_UNCTRL_H_incl
	#define NCURSES_UNCTRL_H_incl 1	#define NCURSES_UNCTRL_H_incl 1

	#undef NCURSES_VERSION	#undef NCURSES_VERSION

	#define NCURSES_VERSION "5.6"	#define NCURSES_VERSION "5.7"

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	#include <ncurses/curses.h>	#include <ncurses/curses.h>

	#undef unctrl	#undef unctrl
	NCURSES_EXPORT(NCURSES_CONST char *) unctrl (chtype);	NCURSES_EXPORT(NCURSES_CONST char *) unctrl (chtype);


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	menu.h	menu.h
	/************************************************************************	/************************************************************************

	* Copyright (c) 1998-2002,2003 Free Software Foundation, Inc. *	* Copyright (c) 1998-2003,2007 Free Software Foundation, Inc. *
	* *	* *
	* Permission is hereby granted, free of charge, to any person obtaining a *	* Permission is hereby granted, free of charge, to any person obtaining a *
	* copy of this software and associated documentation files (the *	* copy of this software and associated documentation files (the *
	* "Software"), to deal in the Software without restriction, including *	* "Software"), to deal in the Software without restriction, including *
	* without limitation the rights to use, copy, modify, merge, publish, *	* without limitation the rights to use, copy, modify, merge, publish, *
	* distribute, distribute with modifications, sublicense, and/or sell *	* distribute, distribute with modifications, sublicense, and/or sell *
	* copies of the Software, and to permit persons to whom the Software is *	* copies of the Software, and to permit persons to whom the Software is *
	* furnished to do so, subject to the following conditions: *	* furnished to do so, subject to the following conditions: *
	* *	* *
	* The above copyright notice and this permission notice shall be included *	* The above copyright notice and this permission notice shall be included *

	skipping to change at line 33	skipping to change at line 33
	* Except as contained in this notice, the name(s) of the above copyright *	* Except as contained in this notice, the name(s) of the above copyright *
	* holders shall not be used in advertising or otherwise to promote the *	* holders shall not be used in advertising or otherwise to promote the *
	* sale, use or other dealings in this Software without prior written *	* sale, use or other dealings in this Software without prior written *
	* authorization. *	* authorization. *
	************************************************************************ /	************************************************************************ /

	/************************************************************************	/************************************************************************
	* Author: Juergen Pfeifer, 1995,1997 *	* Author: Juergen Pfeifer, 1995,1997 *
	************************************************************************ /	************************************************************************ /


	/* $Id: menu.h,v 1.18 2003/11/08 20:48:24 tom Exp $ */	/* $Id: menu.h,v 1.19 2007/02/24 17:32:13 tom Exp $ */

	#ifndef ETI_MENU	#ifndef ETI_MENU
	#define ETI_MENU	#define ETI_MENU

	#ifdef AMIGA	#ifdef AMIGA
	#define TEXT TEXT_ncurses	#define TEXT TEXT_ncurses
	#endif	#endif

	#include <ncurses/curses.h>	#include <ncurses/curses.h>
	#include <ncurses/eti.h>	#include <ncurses/eti.h>

	skipping to change at line 218	skipping to change at line 218
	extern NCURSES_EXPORT(int) item_opts_off (ITEM *,Item_Options);	extern NCURSES_EXPORT(int) item_opts_off (ITEM *,Item_Options);
	extern NCURSES_EXPORT(int) item_opts_on (ITEM *,Item_Options);	extern NCURSES_EXPORT(int) item_opts_on (ITEM *,Item_Options);
	extern NCURSES_EXPORT(int) menu_driver (MENU *,int);	extern NCURSES_EXPORT(int) menu_driver (MENU *,int);
	extern NCURSES_EXPORT(int) menu_opts_off (MENU *,Menu_Options);	extern NCURSES_EXPORT(int) menu_opts_off (MENU *,Menu_Options);
	extern NCURSES_EXPORT(int) menu_opts_on (MENU *,Menu_Options);	extern NCURSES_EXPORT(int) menu_opts_on (MENU *,Menu_Options);
	extern NCURSES_EXPORT(int) menu_pad (const MENU *);	extern NCURSES_EXPORT(int) menu_pad (const MENU *);
	extern NCURSES_EXPORT(int) pos_menu_cursor (const MENU *);	extern NCURSES_EXPORT(int) pos_menu_cursor (const MENU *);
	extern NCURSES_EXPORT(int) post_menu (MENU *);	extern NCURSES_EXPORT(int) post_menu (MENU *);
	extern NCURSES_EXPORT(int) scale_menu (const MENU ,int ,int *);	extern NCURSES_EXPORT(int) scale_menu (const MENU ,int ,int *);
	extern NCURSES_EXPORT(int) set_current_item (MENU menu,ITEM item);	extern NCURSES_EXPORT(int) set_current_item (MENU menu,ITEM item);

	extern NCURSES_EXPORT(int) set_item_init (MENU ,void()(MENU *));	extern NCURSES_EXPORT(int) set_item_init (MENU *, Menu_Hook);
	extern NCURSES_EXPORT(int) set_item_opts (ITEM *,Item_Options);	extern NCURSES_EXPORT(int) set_item_opts (ITEM *,Item_Options);

	extern NCURSES_EXPORT(int) set_item_term (MENU ,void()(MENU *));	extern NCURSES_EXPORT(int) set_item_term (MENU *, Menu_Hook);
	extern NCURSES_EXPORT(int) set_item_userptr (ITEM , void );	extern NCURSES_EXPORT(int) set_item_userptr (ITEM , void );
	extern NCURSES_EXPORT(int) set_item_value (ITEM *,bool);	extern NCURSES_EXPORT(int) set_item_value (ITEM *,bool);
	extern NCURSES_EXPORT(int) set_menu_back (MENU *,chtype);	extern NCURSES_EXPORT(int) set_menu_back (MENU *,chtype);
	extern NCURSES_EXPORT(int) set_menu_fore (MENU *,chtype);	extern NCURSES_EXPORT(int) set_menu_fore (MENU *,chtype);
	extern NCURSES_EXPORT(int) set_menu_format (MENU *,int,int);	extern NCURSES_EXPORT(int) set_menu_format (MENU *,int,int);
	extern NCURSES_EXPORT(int) set_menu_grey (MENU *,chtype);	extern NCURSES_EXPORT(int) set_menu_grey (MENU *,chtype);

	extern NCURSES_EXPORT(int) set_menu_init (MENU ,void()(MENU *));	extern NCURSES_EXPORT(int) set_menu_init (MENU *, Menu_Hook);
	extern NCURSES_EXPORT(int) set_menu_items (MENU ,ITEM *);	extern NCURSES_EXPORT(int) set_menu_items (MENU ,ITEM *);
	extern NCURSES_EXPORT(int) set_menu_mark (MENU , const char );	extern NCURSES_EXPORT(int) set_menu_mark (MENU , const char );
	extern NCURSES_EXPORT(int) set_menu_opts (MENU *,Menu_Options);	extern NCURSES_EXPORT(int) set_menu_opts (MENU *,Menu_Options);
	extern NCURSES_EXPORT(int) set_menu_pad (MENU *,int);	extern NCURSES_EXPORT(int) set_menu_pad (MENU *,int);
	extern NCURSES_EXPORT(int) set_menu_pattern (MENU ,const char );	extern NCURSES_EXPORT(int) set_menu_pattern (MENU ,const char );
	extern NCURSES_EXPORT(int) set_menu_sub (MENU ,WINDOW );	extern NCURSES_EXPORT(int) set_menu_sub (MENU ,WINDOW );

	extern NCURSES_EXPORT(int) set_menu_term (MENU ,void()(MENU *));	extern NCURSES_EXPORT(int) set_menu_term (MENU *, Menu_Hook);
	extern NCURSES_EXPORT(int) set_menu_userptr (MENU ,void );	extern NCURSES_EXPORT(int) set_menu_userptr (MENU ,void );
	extern NCURSES_EXPORT(int) set_menu_win (MENU ,WINDOW );	extern NCURSES_EXPORT(int) set_menu_win (MENU ,WINDOW );
	extern NCURSES_EXPORT(int) set_top_row (MENU *,int);	extern NCURSES_EXPORT(int) set_top_row (MENU *,int);
	extern NCURSES_EXPORT(int) top_row (const MENU *);	extern NCURSES_EXPORT(int) top_row (const MENU *);
	extern NCURSES_EXPORT(int) unpost_menu (MENU *);	extern NCURSES_EXPORT(int) unpost_menu (MENU *);
	extern NCURSES_EXPORT(int) menu_request_by_name (const char *);	extern NCURSES_EXPORT(int) menu_request_by_name (const char *);
	extern NCURSES_EXPORT(int) set_menu_spacing (MENU *,int,int,int);	extern NCURSES_EXPORT(int) set_menu_spacing (MENU *,int,int,int);
	extern NCURSES_EXPORT(int) menu_spacing (const MENU ,int ,int ,int );	extern NCURSES_EXPORT(int) menu_spacing (const MENU ,int ,int ,int );

	extern NCURSES_EXPORT(bool) item_value (const ITEM *);	extern NCURSES_EXPORT(bool) item_value (const ITEM *);

End of changes. 6 change blocks.
	6 lines changed or deleted	6 lines changed or added