398 lines
9.0 KiB
C++
398 lines
9.0 KiB
C++
// 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 GNU CC.
|
|
|
|
GNU CC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY. No author or distributor
|
|
accepts responsibility to anyone for the consequences of using it
|
|
or for whether it serves any particular purpose or works at all,
|
|
unless he says so in writing. Refer to the GNU CC General Public
|
|
License for full details.
|
|
|
|
Everyone is granted permission to copy, modify and redistribute
|
|
GNU CC, but only under the conditions described in the
|
|
GNU CC General Public License. A copy of this license is
|
|
supposed to have been given to you along with GNU CC so you
|
|
can know your rights and responsibilities. It should be in a
|
|
file named COPYING. Among other things, the copyright notice
|
|
and this notice must be preserved on all copies.
|
|
*/
|
|
|
|
#ifndef _CursesWindow_h
|
|
#ifdef __GNUG__
|
|
#pragma once
|
|
#pragma interface
|
|
#endif
|
|
#define _CursesWindow_h
|
|
#ifdef __GNUG__
|
|
#pragma once
|
|
#pragma interface
|
|
#endif
|
|
|
|
#include <curses.h>
|
|
|
|
/*
|
|
*
|
|
* 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, 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(cbool bf);
|
|
int clrtobot();
|
|
int clrtoeol();
|
|
int delch();
|
|
int mvdelch(int y, int x);
|
|
int deleteln();
|
|
|
|
// screen control
|
|
int scroll();
|
|
int scrollok(cbool bf);
|
|
int touchwin();
|
|
int refresh();
|
|
int leaveok(cbool bf);
|
|
int flushok(cbool bf);
|
|
int standout();
|
|
int standend();
|
|
|
|
// multiple window control
|
|
int overlay(CursesWindow &win);
|
|
int overwrite(CursesWindow &win);
|
|
|
|
|
|
// traversal support
|
|
CursesWindow* child();
|
|
CursesWindow* sibling();
|
|
CursesWindow* parent();
|
|
};
|
|
|
|
#if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
|
|
|
|
|
|
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)
|
|
{
|
|
return ::waddstr(w, 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)==0) ? 0 : ::waddch(w, ch);
|
|
}
|
|
|
|
inline int CursesWindow::mvgetch(int y, int x)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::wgetch(w);
|
|
}
|
|
|
|
inline int CursesWindow::mvaddstr(int y, int x, char * str)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::waddstr(w, str);
|
|
}
|
|
|
|
inline int CursesWindow::mvgetstr(int y, int x, char * str)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::wgetstr(w, str);
|
|
}
|
|
|
|
inline int CursesWindow::mvinch(int y, int x)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::winch(w);
|
|
}
|
|
|
|
inline int CursesWindow::mvdelch(int y, int x)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::wdelch(w);
|
|
}
|
|
|
|
inline int CursesWindow::mvinsch(int y, int x, char ch)
|
|
{
|
|
return (::wmove(w, y, x)==0) ? 0 : ::winsch(w, ch);
|
|
}
|
|
|
|
inline int CursesWindow::refresh()
|
|
{
|
|
return ::wrefresh(w);
|
|
}
|
|
|
|
inline int CursesWindow::clearok(cbool bf)
|
|
{
|
|
return ::clearok(w,bf);
|
|
}
|
|
|
|
inline int CursesWindow::leaveok(cbool bf)
|
|
{
|
|
return ::leaveok(w,bf);
|
|
}
|
|
|
|
inline int CursesWindow::scrollok(cbool bf)
|
|
{
|
|
return ::scrollok(w,bf);
|
|
}
|
|
|
|
inline int CursesWindow::flushok(cbool bf)
|
|
{
|
|
return ::flushok(w, bf);
|
|
}
|
|
|
|
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
|
|
#endif
|