d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2f822e9be7
freebsd-skq/gnu/lib/libg++/include/CursesW.h
Poul-Henning Kamp 61d5ffaf10 I belive this should be makeable under 2.0. There may be outstanding 
issues in these areas:
    .h's installed
    .hP's installed
    -lcurses interaction
    files needed in ~/legal for copyleft reasons.
1994-08-08 05:52:55 +00:00

591 lines
14 KiB
C++
Raw Blame History

// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1989 Free Software Foundation
written by Eric Newton (newton@rocky.oswego.edu)
This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. This library is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _CursesWindow_h
#ifdef __GNUG__
#pragma interface
#endif
#define _CursesWindow_h
#include <_G_config.h>
#if _G_HAVE_CURSES
#include <curses.h>
/* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
Undefine it here, because CursesWindow uses lines as a method. */
#undef lines
// "Convert" macros to inlines, if needed.
#ifdef addch
inline int (addch)(char ch) { return addch(ch); }
#undef addch
#endif
#ifdef addstr
/* The (char*) cast is to hack around missing const's */
inline int (addstr)(const char * str) { return addstr((char*)str); }
#undef addstr
#endif
#ifdef clear
inline int (clear)() { return clear(); }
#undef clear
#endif
#ifdef clearok
inline int (clearok)(WINDOW* win, int bf) { return clearok(win, bf); }
#undef clearok
#else
extern "C" int clearok(WINDOW*, int);
#endif
#ifdef clrtobot
inline int (clrtobot)() { return clrtobot(); }
#undef clrtobot
#endif
#ifdef clrtoeol
inline int (clrtoeol)() { return clrtoeol(); }
#undef clrtoeol
#endif
#ifdef delch
inline int (delch)() { return delch(); }
#undef delch
#endif
#ifdef deleteln
inline int (deleteln)() { return deleteln(); }
#undef deleteln
#endif
#ifdef erase
inline int (erase)() { return erase(); }
#undef erase
#endif
#ifdef flushok
inline int (flushok)(WINDOW* _win, int _bf) { return flushok(_win, _bf); }
#undef flushok
#else
#define _no_flushok
#endif
#ifdef getch
inline int (getch)() { return getch(); }
#undef getch
#endif
#ifdef getstr
inline int (getstr)(char *_str) { return getstr(_str); }
#undef getstr
#endif
#ifdef getyx
inline void (getyx)(WINDOW* win, int& y, int& x) { getyx(win, y, x); }
#undef getyx
#endif
#ifdef inch
inline int (inch)() { return inch(); }
#undef inch
#endif
#ifdef insch
inline int (insch)(char c) { return insch(c); }
#undef insch
#endif
#ifdef insertln
inline int (insertln)() { return insertln(); }
#undef insertln
#endif
#ifdef leaveok
inline int (leaveok)(WINDOW* win, int bf) { return leaveok(win, bf); }
#undef leaveok
#else
extern "C" int leaveok(WINDOW* win, int bf);
#endif
#ifdef move
inline int (move)(int x, int y) { return move(x, y); }
#undef move
#endif
#ifdef refresh
inline int (rfresh)() { return refresh(); }
#undef refresh
#endif
#ifdef scrollok
inline int (scrollok)(WINDOW* win, int bf) { return scrollok(win, bf); }
#undef scrollok
#else
#ifndef hpux
extern "C" int scrollok(WINDOW*, int);
#else
extern "C" int scrollok(WINDOW*, char);
#endif
#endif
#ifdef standend
inline int (standend)() { return standend(); }
#undef standend
#endif
#ifdef standout
inline int (standout)() { return standout(); }
#undef standout
#endif
#ifdef wstandend
inline int (wstandend)(WINDOW *win) { return wstandend(win); }
#undef wstandend
#endif
#ifdef wstandout
inline int (wstandout)(WINDOW *win) { return wstandout(win); }
#undef wstandout
#endif
#ifdef winch
inline int (winch)(WINDOW* win) { return winch(win); }
#undef winch
#endif
/* deal with conflicting macros in ncurses.h which is SYSV based*/
#ifdef box
inline (box)(WINDOW* win, chtype v, chtype h) {return box(win, v, h); }
#undef box
#endif
#ifdef scroll
inline (scroll)(WINDOW* win) { return scroll(win); }
#undef scroll
#endif
#ifdef touchwin
inline (touchwin)(WINDOW* win) { return touchwin(win); }
#undef touchwin
#endif
#ifdef mvwaddch
inline int (mvwaddch)(WINDOW *win, int y, int x, char ch)
{ return mvwaddch(win, y, x, ch); }
#undef mvwaddch
#endif
#ifdef mvwaddstr
inline int (mvwaddstr)(WINDOW *win, int y, int x, const char * str)
{ return mvwaddstr(win, y, x, (char*)str); }
#undef mvwaddstr
#endif
#ifdef mvwdelch
inline int (mvwdelch)(WINDOW *win, int y, int x) { return mvwdelch(win, y, x);}
#undef mvwdelch
#endif
#ifdef mvwgetch
inline int (mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
#undef mvwgetch
#endif
#ifdef mvwgetstr
inline int (mvwgetstr)(WINDOW *win, int y, int x, char *str)
{return mvwgetstr(win,y,x, str);}
#undef mvwgetstr
#endif
#ifdef mvwinch
inline int (mvwinch)(WINDOW *win, int y, int x) { return mvwinch(win, y, x);}
#undef mvwinch
#endif
#ifdef mvwinsch
inline int (mvwinsch)(WINDOW *win, int y, int x, char c)
{ return mvwinsch(win, y, x, c); }
#undef mvwinsch
#endif
#ifdef mvaddch
inline int (mvaddch)(int y, int x, char ch)
{ return mvaddch(y, x, ch); }
#undef mvaddch
#endif
#ifdef mvaddstr
inline int (mvaddstr)(int y, int x, const char * str)
{ return mvaddstr(y, x, (char*)str); }
#undef mvaddstr
#endif
#ifdef mvdelch
inline int (mvdelch)(int y, int x) { return mvdelch(y, x);}
#undef mvdelch
#endif
#ifdef mvgetch
inline int (mvgetch)(int y, int x) { return mvgetch(y, x);}
#undef mvgetch
#endif
#ifdef mvgetstr
inline int (mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
#undef mvgetstr
#endif
#ifdef mvinch
inline int (mvinch)(int y, int x) { return mvinch(y, x);}
#undef mvinch
#endif
#ifdef mvinsch
inline int (mvinsch)(int y, int x, char c)
{ return mvinsch(y, x, c); }
#undef mvinsch
#endif
/*
*
* C++ class for windows.
*
*
*/
class CursesWindow
{
protected:
static int count; // count of all active windows:
// We rely on the c++ promise that
// all otherwise uninitialized
// static class vars are set to 0
WINDOW * w; // the curses WINDOW
int alloced; // true if we own the WINDOW
CursesWindow* par; // parent, if subwindow
CursesWindow* subwins; // head of subwindows list
CursesWindow* sib; // next subwindow of parent
void kill_subwindows(); // disable all subwindows
public:
CursesWindow(WINDOW* &window); // useful only for stdscr
CursesWindow(int lines, // number of lines
int cols, // number of columns
int begin_y, // line origin
int begin_x); // col origin
CursesWindow(CursesWindow& par, // parent window
int lines, // number of lines
int cols, // number of columns
int by, // absolute or relative
int bx, // origins:
char absrel = 'a'); // if `a', by & bx are
// absolute screen pos,
// else if `r', they are
// relative to par origin
~CursesWindow();
// terminal status
int lines(); // number of lines on terminal, *not* window
int cols(); // number of cols on terminal, *not* window
// window status
int height(); // number of lines in this window
int width(); // number of cols in this window
int begx(); // smallest x coord in window
int begy(); // smallest y coord in window
int maxx(); // largest x coord in window
int maxy(); // largest x coord in window
// window positioning
int move(int y, int x);
// coordinate positioning
void getyx(int& y, int& x);
int mvcur(int sy, int ey, int sx, int ex);
// input
int getch();
int getstr(char * str);
int scanw(const char *, ...);
// input + positioning
int mvgetch(int y, int x);
int mvgetstr(int y, int x, char * str);
int mvscanw(int, int, const char*, ...);
// output
int addch(const char ch);
int addstr(const char * str);
int printw(const char * fmt, ...);
int inch();
int insch(char c);
int insertln();
// output + positioning
int mvaddch(int y, int x, char ch);
int mvaddstr(int y, int x, const char * str);
int mvprintw(int y, int x, const char * fmt, ...);
int mvinch(int y, int x);
int mvinsch(int y, int x, char ch);
// borders
int box(char vert, char hor);
// erasure
int erase();
int clear();
int clearok(int bf);
int clrtobot();
int clrtoeol();
int delch();
int mvdelch(int y, int x);
int deleteln();
// screen control
int scroll();
int scrollok(int bf);
int touchwin();
int refresh();
int leaveok(int bf);
#ifndef _no_flushok
int flushok(int bf);
#endif
int standout();
int standend();
// multiple window control
int overlay(CursesWindow &win);
int overwrite(CursesWindow &win);
// traversal support
CursesWindow* child();
CursesWindow* sibling();
CursesWindow* parent();
};
inline int CursesWindow::begx()
{
return w->_begx;
}
inline int CursesWindow::begy()
{
return w->_begy;
}
inline int CursesWindow::maxx()
{
return w->_maxx;
}
inline int CursesWindow::maxy()
{
return w->_maxy;
}
inline int CursesWindow::height()
{
return maxy() - begy() + 1;
}
inline int CursesWindow::width()
{
return maxx() - begx() + 1;
}
inline int CursesWindow::box(char vert, char hor)
{
return ::box(w, vert, hor);
}
inline int CursesWindow::overlay(CursesWindow &win)
{
return ::overlay(w, win.w);
}
inline int CursesWindow::overwrite(CursesWindow &win)
{
return ::overwrite(w, win.w);
}
inline int CursesWindow::scroll()
{
return ::scroll(w);
}
inline int CursesWindow::touchwin()
{
return ::touchwin(w);
}
inline int CursesWindow::addch(const char ch)
{
return ::waddch(w, ch);
}
inline int CursesWindow::addstr(const char * str)
{
// The (char*) cast is to hack around prototypes in curses.h that
// have const missing in the parameter lists. [E.g. SVR4]
return ::waddstr(w, (char*)str);
}
inline int CursesWindow::clear()
{
return ::wclear(w);
}
inline int CursesWindow::clrtobot()
{
return ::wclrtobot(w);
}
inline int CursesWindow::clrtoeol()
{
return ::wclrtoeol(w);
}
inline int CursesWindow::delch()
{
return ::wdelch(w);
}
inline int CursesWindow::deleteln()
{
return ::wdeleteln(w);
}
inline int CursesWindow::erase()
{
return ::werase(w);
}
inline int CursesWindow::getch()
{
return ::wgetch(w);
}
inline int CursesWindow::getstr(char * str)
{
return ::wgetstr(w, str);
}
inline int CursesWindow::inch()
{
return winch(w);
}
inline int CursesWindow::insch(char c)
{
return ::winsch(w, c);
}
inline int CursesWindow::insertln()
{
return ::winsertln(w);
}
inline int CursesWindow::move(int y, int x)
{
return ::wmove(w, y, x);
}
inline int CursesWindow::mvcur(int sy, int ey, int sx, int ex)
{
return ::mvcur(sy, ey, sx,ex);
}
inline int CursesWindow::mvaddch(int y, int x, char ch)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::waddch(w, ch);
}
inline int CursesWindow::mvgetch(int y, int x)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::wgetch(w);
}
inline int CursesWindow::mvaddstr(int y, int x, const char * str)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::waddstr(w, (char*)str);
}
inline int CursesWindow::mvgetstr(int y, int x, char * str)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::wgetstr(w, str);
}
inline int CursesWindow::mvinch(int y, int x)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::winch(w);
}
inline int CursesWindow::mvdelch(int y, int x)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::wdelch(w);
}
inline int CursesWindow::mvinsch(int y, int x, char ch)
{
return (::wmove(w, y, x)==ERR) ? ERR : ::winsch(w, ch);
}
inline int CursesWindow::refresh()
{
return ::wrefresh(w);
}
inline int CursesWindow::clearok(int bf)
{
return ::clearok(w,bf);
}
inline int CursesWindow::leaveok(int bf)
{
return ::leaveok(w,bf);
}
inline int CursesWindow::scrollok(int bf)
{
return ::scrollok(w,bf);
}
#ifndef _no_flushok
inline int CursesWindow::flushok(int bf)
{
return ::flushok(w, bf);
}
#endif
inline void CursesWindow::getyx(int& y, int& x)
{
::getyx(w, y, x);
}
inline int CursesWindow::standout()
{
return ::wstandout(w);
}
inline int CursesWindow::standend()
{
return ::wstandend(w);
}
inline int CursesWindow::lines()
{
return LINES;
}
inline int CursesWindow::cols()
{
return COLS;
}
inline CursesWindow* CursesWindow::child()
{
return subwins;
}
inline CursesWindow* CursesWindow::parent()
{
return par;
}
inline CursesWindow* CursesWindow::sibling()
{
return sib;
}
#endif /* _G_HAVE_CURSES */
#endif
Reference in New Issue View Git Blame Copy Permalink