/* Terminalhanterare för Linux *:85 VT 2003              */
/* Av Jozef Swiatycki                                    */

extern "C" {
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#ifndef TIOCGWINSZ
#include <sys/ioctl.h>
#endif
#include <signal.h>
#include <unistd.h>
}

#include "terminal.h"

#define FKEYUNDEF 400

#if 0
#define KBDEBUG
#endif

namespace {

  // Escape-sekvenser genererade av funktionstangenter enligt VT100

  const char *fkeytab[]={
                   "[11~",       /* F1 */
		   "[12~",	 /* F2 */
		   "[13~",	 /* F3 */
		   "[14~",	 /* F4 */
		   "[15~",	 /* F5 */
		   "[17~",	 /* F6 */
		   "[18~",	 /* F7 */
		   "[19~",	 /* F8 */
		   "[20~",	 /* F9 */
		   "[21~",	 /* F10 */
		   "[23~",       /* F11 */
		   "[24~",	 /* F12 */
		   "[25~",	 /* F13 */
		   "[26~",	 /* F14 */
		   "[28~",	 /* Hjälp */
		   "[29~",	 /* Utför */
		   "[31~",	 /* F17 */
		   "[32~",	 /* F18 */
		   "[33~",	 /* F19 */
		   "[34~",	 /* F20 */
		   "[1~",	 /* Home (gamla Sök) */
		   "[2~",	 /* Sätt in */
		   "[3~",	 /* Ta bort */
		   "[4~",	 /* End (gamla Välj ut) */
		   "[5~",	 /* Pageup (gamla Föreg) */
		   "[6~",	 /* Pagedown (gamla Nästa) */
		   "OA",	 /* Upp */
		   "OB",	 /* Ner */
		   "OD",	 /* Vänster */
		   "OC",	 /* Höger */
		   "OP",	 /* PF1 */
		   "OQ",	 /* PF2 */
		   "OR",	 /* PF3 */
		   "OS",	 /* PF4 */
		   "Oj",         /* NKP x */
		   "Ok",         /* NKP + */
		   "Oo",         /* NKP / */
		   "Op",	 /* NKP 0 */
		   "Oq",	 /* NKP 1 */
		   "Or",	 /* NKP 2 */
		   "Os",	 /* NKP 3 */
		   "Ot",	 /* NKP 4 */
		   "Ou",	 /* NKP 5 */
		   "Ov",	 /* NKP 6 */
		   "Ow",	 /* NKP 7 */
		   "Ox",	 /* NKP 8 */
		   "Oy",	 /* NKP 9 */
		   "Om",	 /* NKP - */
		   "Ol",	 /* NKP , */
		   "On",	 /* NKP . */
		   "OM"		 /* NKP Enter */
	       };

  const int FKEYMAX = sizeof(fkeytab) / sizeof(unsigned char *);

  enum FKnames { FK_F1, FK_F2, FK_F3, FK_F4, FK_F5, FK_F6, FK_F7,
		 FK_F8, FK_F9, FK_F10, FK_F11, FK_F12, FK_F13, FK_F14,
		 FK_Help, FK_Execute, FK_F17, FK_F18, FK_F19, FK_F20,
		 FK_Home, FK_Insert, FK_Delete, FK_End, FK_Pageup, 
		 FK_Pagedown, FK_Up, FK_Down, FK_Left, FK_Right,
		 FK_PF1, FK_PF2, FK_PF3, FK_PF4, FK_NKPtimes, FK_NKPplus,
		 FK_NKPdiv, FK_NKP0, FK_NKP1, FK_NKP2, FK_NKP3, FK_NKP4,
		 FK_NKP5, FK_NKP6, FK_NKP7, FK_NKP8, FK_NKP9, FK_NKPminus,
		 FK_NKPcomma, FK_NKPdot, FK_NKPenter};
  
  struct replstruct { 
    FKnames fkname; 
    const char *fkstr;
  };

  const replstruct xtermtab[] = {
    {FK_F1, "OP"},
    {FK_F2, "OQ"},
    {FK_F3, "OR"},
    {FK_F4, "OS"},
    {FK_Home, "OH"},
    {FK_End, "OF"}
  };

  const replstruct linuxtab[] = {
    {FK_F1, "[[A"},
    {FK_F2, "[[B"},
    {FK_F3, "[[C"},
    {FK_F4, "[[D"},
    {FK_F5, "[[E"}
  };

  const char * const gc[]={"jklmnqtuvwx",
		    "gtrf/,5687."};


  struct repls{
    const char *type;
    const replstruct *replace;
    int siz;
    int tix;
  } repltab[] = { {"vt220", NULL, 0, 1},
		  {"xterm",xtermtab,sizeof(xtermtab)/sizeof(replstruct),0},
		  {"xterm-color",xtermtab,sizeof(xtermtab)/sizeof(replstruct),0},
		  {"linux",linuxtab,sizeof(linuxtab)/sizeof(replstruct),0}
                };

  const int NOTT = sizeof(repltab) / sizeof(repls);

  const char *capatab[]={
    "\033[J",                 /* Clear to end of display */
    "\033[1J",                /* Clear from begining of display */
    "\033[0K",                /* Clear to end of line    */
    "\033[1K",                /* Clear begining of line  */
    "\033[2K",                /* Clear line              */
    "\033[;H\033[2J",         /* Clear screen            */
    "\033[%d;%dH",            /* Cursor motion           */
    "\033[%d;%dr",            /* Change scrolling region */
    "\033[3g",                /* Clear all tab stops     */
    "\033[%dB",               /* Move down one line      */
    "\033[H",                 /* Home cursor             */
    "\033[1;%dr\033[%d;1H",   /* Initialization string   */
    "\033[?1l\033>",          /* Out of keypad transmit mode */
    "\033[?1h\033=",          /* Keypad transmit mode on */
    "\033[%dD",               /* Move cursor left one place */
    "\033[5m",                /* Turn on blinking        */
    "\033[1m",                /* Enter bold mode         */
    "\033[m",                 /* Enter normal mode       */
    "\033[7m",                /* Enter reverse mode      */
    "\033[%dC",               /* Nondestructive space    */
    "\033[m",                 /* End stand-out mode      */
    "\033[7m",                /* Begin stand-out mode    */
    "\033[M",                 /* Scroll reverse          */
    "\033[m",                 /* End underscore mode     */
    "\033[%dA",               /* Up one line             */
    "\033[4m",                /* Start underscore mode   */
    "\033[6n",                /* Request Cursor Position */
    "\033[%d;%dR",            /* Cursor Position Answer */
    "\033)0",                 /* Choose graphics as G1 */
    "\016",                   /* Switch to G1 (graphics) */
    "\033N",                  /* Switch to G2 (graphics) next char only */
    "\017",                   /* Switch to G0 (normal) */
    "\033[?8h",               /* Auto-repeat keys */
    "\0337",                  /* Save cursor and attributes */
    "\0338",                  /* Restore cursor and attributes */
    "\033[%d@",               /* Insert characters */
    "\033[%dP",               /* Delete characters */
    "\033[%dX",               /* Erase charcters  */
    "\033[%dS",               /* Scroll up */
    "\033[%dT",               /* Scroll down */
    "\033[3%dm",              /* Set foreground colour */
    "\033[4%dm",              /* Set background colour */
    "\033[%dL",               /* Insert lines */
    "\033[%dM",               /* Delete lines */
    "\033[8;%d;%dt"           /* Resize window */
  };


  enum {CLRED, CLRBD, CLREL, CLRBL, CLRL, CLRSCR, CURMOV, CHSCRL, CLTABS,
	MOVDOWN, HOMCUR, INISTR, KPEND, KPBEG, MOVLEFT, BLINKON, BOLDON, 
	NORMON, REVON, MOVRIGHT, STANDOUTOFF, STANDOUTON, SCROLLREV, 
	UNDEROFF, MOVUP, UNDERON, POSREQ, POSANS, SETGRAPH, GRAPHON, 
	GRAPHNEXT,GRAPHOFF, AUTOREP, SAVECUR, RESETCUR, INSERT, DELETE,
	ERASE, SCROLLUP, SCROLLDOWN, FGCOLOUR, BGCOLOUR, INSLINS, DELLINS,
	RESWIN };


    enum {LRCORN, URCORN, ULCORN, LLCORN, CROSS, HORL,
	  TLEFT, TRIGHT, TBOTTOM, TTOP, VERL};
    
  int tx;
  bool gron=false;
  struct termios savedterm;
  int rows=24, cols=80;
  bool szchd=false;
  void (*drawfunc)()=NULL;


  int tix(const char *str){
    for(int i=0; i<NOTT; i++)
      if (!strcmp(str, repltab[i].type))
	return i;
    return 0;
  }

  void replace(int ix){
    tx=repltab[ix].tix;
    for(int i=0; i < repltab[ix].siz; i++)
      fkeytab[repltab[ix].replace[i].fkname]=repltab[ix].replace[i].fkstr;
  }

  void resetterm(){
    printf(capatab[INISTR], rows, rows); fflush(stdout);
    printf(capatab[GRAPHOFF]); fflush(stdout);
    printf(capatab[NORMON]); fflush(stdout);
    tcsetattr(fileno(stdin), TCSAFLUSH, &savedterm);
  }
  

  void onctrlc(int sig){
    resetterm();
    exit(0);
  }

  void onerror(int sig){
    resetterm();
    signal(sig, SIG_DFL);
    return;
  }

  void getwinsz(){
    struct winsize ws;
    ioctl(fileno(stdin), TIOCGWINSZ, (char *) &ws);
    rows=ws.ws_row;
    cols=ws.ws_col;
  }

  void onwinsiz(int sig){
    getwinsz();
    szchd=1;
    if (drawfunc) drawfunc();
  }
  
  void initterm(){
    struct termios outterm;
  
    setbuf(stdin, NULL);
    int ix=tix(getenv("TERM"));
    replace(ix);
    tcgetattr(fileno(stdin), &savedterm);
    outterm=savedterm;
    outterm.c_lflag &= ~(ECHO | ICANON);
    outterm.c_iflag &= ~ICRNL;
    outterm.c_cc[VMIN]=1;
    outterm.c_cc[VTIME]=0;
    tcsetattr(fileno(stdin), TCSANOW, &outterm);
    getwinsz();
    printf(capatab[KPBEG]);   fflush(stdout);
    printf(capatab[INISTR], rows, rows);  fflush(stdout);
    printf(capatab[SETGRAPH]);  fflush(stdout);
    printf(capatab[AUTOREP]);  fflush(stdout);
    signal(SIGINT, onctrlc);
    signal(SIGBUS, onerror);
    signal(SIGSEGV,onerror);
    signal(SIGWINCH, onwinsiz);
  }

  int fkeycode(const char *fkstr){
    for (int i=0; i<FKEYMAX; i++) {
      if (!strcmp(fkstr, fkeytab[i]))
	return 256+i;
      if (!strncmp(fkstr, fkeytab[i], strlen(fkstr)))
	return 0;
    }
    return FKEYUNDEF;
  }

  int readkey(){
    /* unsigned */ char c;
    /* unsigned */ char buff[512];
    int i=0, ret;

    read(fileno(stdin), &c, 1);
#ifdef KBDEBUG
    if (c=='\033')
      printf("ESC ");
    else
      printf("%c %d ", c, c);
    fflush(stdout);
#endif
    if (c!='\033')
      return c;
    do{
      read(fileno(stdin), &buff[i++], 1);
#ifdef KBDEBUG
      if (buff[i-1]=='\033')
	printf("ESC ");
      else
	printf("%c %d", buff[i-1], buff[i-1]);
      fflush(stdout);
#endif
      buff[i]='\0';
    } while (!(ret=fkeycode(buff)));
    
    return ret;
  }


  void graphicson(){
    printf(capatab[GRAPHON]);
    fflush(stdout);
    gron=true;
  }

  void graphicsoff(){
    printf(capatab[GRAPHOFF]);
    fflush(stdout);
    gron=false;
}

  void lrcorn(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][LRCORN]);
    fflush(stdout);
  }

  void urcorn(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][URCORN]);
    fflush(stdout);
  }

  void ulcorn(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][ULCORN]);
    fflush(stdout);
  }

  void llcorn(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][LLCORN]);
    fflush(stdout);
  }

  void cross(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][CROSS]);
    fflush(stdout);
  }

  void tleft(){
    if (!gron){
      printf(capatab[GRAPHNEXT]);
      fflush(stdout);
    }
    putchar(gc[tx][TLEFT]);
    fflush(stdout);
  }

  void tright(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][TRIGHT]);
    fflush(stdout);
  }
  
  void tbottom(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][TBOTTOM]);
    fflush(stdout);
  }
  
  void ttop(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][TTOP]);
    fflush(stdout);
  }
  
  void horl(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][HORL]);
    fflush(stdout);
  }

  void verl(){
    if (!gron){
#if 0
      printf(capatab[GRAPHNEXT]);
#endif
      printf(capatab[GRAPHON]);
      fflush(stdout);
    }
    putchar(gc[tx][VERL]);
    fflush(stdout);
  }

} // the anonymous namespace

namespace terminal_star85 {

  bool terminal::exists = false;

  terminal::terminal(){
    if (exists){
      std::cerr << "Attempt to reinitiate terminal!" << std::endl;
      resetterm();
      abort();
    }
    exists=true;
    initterm();
  }

  terminal::~terminal() {
    resetterm();
    exists=false;
  }

  Event terminal::getNextEvent() {
    Event eve;
    eve.what=static_cast<terminal::Keycodes>(readkey());
    curget(eve.whereX, eve.whereY);
    return eve;
  }

  void terminal::clrscr(){
    printf(capatab[CLRSCR]);
    fflush(stdout);
  }

  void terminal::clreod(){
    printf(capatab[CLRED]);
    fflush(stdout);
  }

  void terminal::clrbod(){
    printf(capatab[CLRBD]);
    fflush(stdout); 
  }

  void terminal::clrbol(){
    printf(capatab[CLRBL]);
    fflush(stdout);
  }

  void terminal::clreol(){
    printf(capatab[CLREL]);
    fflush(stdout);
  }

  void terminal::clrln(){
    printf(capatab[CLRL]);
    fflush(stdout);
  }

  void terminal::curmove(int x, int y){
    printf(capatab[CURMOV],y, x);
    fflush(stdout);
  }

  void terminal::chscroll(int x, int y){
    printf(capatab[CHSCRL],x,y);
    fflush(stdout);
  }

  void terminal::curdown(int n){
    printf(capatab[MOVDOWN],n);
    fflush(stdout);
  }

  void terminal::curleft(int n){
    printf(capatab[MOVLEFT],n);
    fflush(stdout);
  }

  void terminal::curright(int n){
    printf(capatab[MOVRIGHT],n);
    fflush(stdout);
  }

  void terminal::curup(int n){
    printf(capatab[MOVUP],n);
    fflush(stdout);
  }

  void terminal::curget(int& x, int& y){
    char buf[10];
    int i=0;
    printf(capatab[POSREQ]);
    fflush(stdout);
    do{
      read(fileno(stdin),&buf[i++],1);
    }while (buf[i-1]!='R');
    buf[i]='\0';
    sscanf(buf,capatab[POSANS], &y, &x);
  }

  void terminal::savecur(){
    printf(capatab[SAVECUR]);
    fflush(stdout);
  }

  void terminal::restcur(){
    printf(capatab[RESETCUR]);
    fflush(stdout);
  }

  void terminal::bold(){
    printf(capatab[BOLDON]);
    fflush(stdout);
  }

  void terminal::reverse(){
    printf(capatab[REVON]);
    fflush(stdout);
  }

  void terminal::underline(){
    printf(capatab[UNDERON]);
    fflush(stdout);
  }

  void terminal::normal(){
    printf(capatab[NORMON]);
    graphicsoff();
    fflush(stdout);
  }

  void terminal::horline(int row, int fcol, int tcol){
    int savx, savy;
    curget(savx, savy);
    curmove(fcol, row);
    graphicson();
    for (int i=fcol; i<=tcol; i++)
      horl();
    graphicsoff();
    curmove(savx, savy);
  }

  void terminal::verline(int col, int frow, int trow){
    int savx, savy;
    curget(savx, savy);
    curmove(col, frow);
    graphicson();
    for (int i=frow;i<=trow;i++){
      curmove(col,i);
      verl();
    }
    graphicsoff();
    curmove(savx, savy);
  }

  void terminal::box(int a, int b, int c, int d){
    int i;
    int savx, savy;
    curget(savx, savy);
    graphicson();
    curmove(a,b);
    ulcorn();
    for (i=a+1; i<c; i++)
      horl();
    urcorn();
    for (i=b+1; i<d;i++){
      curmove(c,i);
      verl();
    }
    curmove(c,d);
    lrcorn();
    for(i=c-1; i>a; i--){
      curmove(i,d);
      horl();
    }
    curmove(a,d);
    llcorn();
    for(i=d-1; i>b; i--){
      curmove(a,i);
      verl();
    }
    graphicsoff();
    curmove(savx, savy);
  }

  void terminal::table(int x, int y, std::vector<int> rows, std::vector<int> cols){
    typedef std::vector<int>::size_type sint;
    int r=1;
    int savx, savy;
    curget(savx, savy);
    graphicson();
    curmove(x,y);
    ulcorn();
    for(sint tc=0; tc<cols.size(); tc++){
      for(int sc=0; sc<cols[tc]; sc++)
	horl();
      if (tc<cols.size()-1) ttop(); else urcorn();
    }
    for(sint tr=0; tr<rows.size(); tr++){
      for(int sr=0; sr<rows[tr]; sr++){
	for(sint tc=0, c=0; tc<=cols.size(); tc++){
	  curmove(x+c, y+r);
	  verl();
	  c+=cols[tc]+1;
	}
	r++;
      }
      if (tr<rows.size()-1){
	curmove(x,y+r);
	tleft();
	for(sint tc=0; tc<cols.size(); tc++){
	  for(int sc=0; sc<cols[tc]; sc++) horl();
	  if (tc<cols.size()-1) cross(); else tright();
	}
      }
      else {
	curmove(x,y+r);
	llcorn();
	for(sint tc=0; tc<cols.size(); tc++){
	  for(int sc=0; sc<cols[tc]; sc++) horl();
	  if (tc<cols.size()-1) tbottom(); else lrcorn();
	}
      }
      r++;
    }
    graphicsoff();
    curmove(savx, savy);
  }

  int terminal::height(){ return rows; }

  int terminal::width(){ return cols; }

  bool terminal::changed(){ bool ret=szchd; szchd=false; return ret; }

  void terminal::onresize(void (*func)()){
    drawfunc=func;
  }

  void terminal::inschar(char c){
    printf(capatab[INSERT],1);
    putchar(c);
    fflush(stdout);
  }

  void terminal::insstr(const char *str){
    int s;
    printf(capatab[INSERT],s=strlen(str));
    printf("%s",str);
    fflush(stdout);
  }

  void terminal::inslines(int n){
    printf(capatab[INSLINS],n);
    fflush(stdout);
  }

  void terminal::delchar(int n){
    printf(capatab[DELETE],n);
    fflush(stdout);
  }

  void terminal::clrchrs(int n){
    printf(capatab[ERASE], n);
    fflush(stdout);
  }

  void terminal::dellines(int n){
    printf(capatab[DELLINS],n);
    fflush(stdout);
  }

  void terminal::scrollup(int n){
    printf(capatab[SCROLLUP],n);
    fflush(stdout);
  }

  void terminal::scrolldown(int n){
    printf(capatab[SCROLLDOWN],n);
    fflush(stdout);
  }

  void terminal::fgcolour(Colour colr){
    printf(capatab[FGCOLOUR], colr);
    fflush(stdout);
  }

  void terminal::bgcolour(Colour colr){
    printf(capatab[BGCOLOUR], colr);
    fflush(stdout);
  }

  void terminal::setsize(int height, int width){
    printf(capatab[RESWIN], rows, cols);
    fflush(stdout);
    getwinsz();
  }


  terminal& curmove(terminal& term, int x, int y){
    term.curmove(x, y);
    return term;
  }

  tmanip2 curmove(int x, int y){
    return tmanip2(curmove, x, y);
  }
  
  terminal& chscroll(terminal& term, int x, int y){
    term.chscroll(x, y);
    return term;
  }
  
  tmanip2 chscroll(int x, int y){
    return tmanip2(chscroll, x, y);
  }
  
  
  terminal& fgcolour(terminal& term, int x){
    term.fgcolour(terminal::Colour(x));
    return term;
  }
  
  tmanip1 fgcolour(int x){
    return tmanip1(fgcolour, x);
  }
  
  terminal& bgcolour(terminal& term, int x){
    term.bgcolour(terminal::Colour(x));
    return term;
  }
  
  tmanip1 bgcolour(int x){
    return tmanip1(bgcolour, x);
  }
  
  terminal& curright(terminal& t, int n){
    t.curright(n);
    return t;
  }
  
  tmanip1 curright(int n){
    return tmanip1(curright, n);
  }
  
  terminal& curleft(terminal& t, int n){
    t.curleft(n);
    return t;
  }
  
  tmanip1 curleft(int n){
    return tmanip1(curleft, n);
  }
  
  terminal& curdown(terminal& t, int n){
    t.curdown(n);
    return t;
  }
  
  tmanip1 curdown(int n){
    return tmanip1(curdown, n);
  }
  
  terminal& curup(terminal& t, int n){
    t.curup(n);
    return t;
  }
  
  tmanip1 curup(int n){
    return tmanip1(curup, n);
  }
  
  terminal& inslines(terminal& t, int n){
    t.inslines(n);
    return t;
  }
  
  tmanip1 inslines(int n){
    return tmanip1(inslines, n);
  }
  
  terminal& delchar(terminal& t, int n){
    t.delchar(n);
    return t;
  }
  
  tmanip1 delchar(int n){
    return tmanip1(delchar, n);
  }
  
  terminal& clrchrs(terminal& t, int n){
    t.clrchrs(n);
    return t;
  }

  tmanip1 clrchrs(int n){
    return tmanip1(clrchrs, n);
  }
  
  terminal& dellines(terminal& t, int n){
    t.dellines(n);
    return t;
  }
  
  tmanip1 dellines(int n){
    return tmanip1(dellines, n);
  }
  
  terminal& scrollup(terminal& t, int n){
    t.scrollup(n);
    return t;
  }
  
  tmanip1 scrollup(int n){
    return tmanip1(scrollup, n);
  }
  
  terminal& scrolldown(terminal& t, int n){
    t.scrolldown(n);
    return t;
  }
  
  tmanip1 scrolldown(int n){
    return tmanip1(scrolldown, n);
  }
  
  terminal& inschar(terminal& t, char c){
    t.inschar(c);
    return t;
  }
  
  tmanipc inschar(char c){
    return tmanipc(inschar, c);
  }
  
  terminal& insstr(terminal& t, const char *str){
    t.insstr(str);
    return t;
  }
  
  tmanips insstr(const char *str){
    return tmanips(insstr, str);
  }
  
  terminal& operator<<(terminal& term, const tmanip1 m){
    return m.f(term, m.x);
  }
  
  terminal& operator<<(terminal& term, const tmanip2 m){
    return m.f(term, m.x, m.y);
  }

  terminal& operator<<(terminal& term, const tmanipc m){
    return m.f(term, m.c);
  }
  
  terminal& operator<<(terminal& term, const tmanips m){
    return m.f(term, m.str);
  }
  
  
  terminal& operator<<(terminal& term, terminal& (*f)(terminal&)){
    return f(term);
  }
  
  terminal& clrscr(terminal& t){
    t.clrscr();
    return t;
  }
  
  terminal& clreod(terminal& t){
    t.clreod();
    return t;
  }
  
  terminal& clrbod(terminal& t){
    t.clrbod();
    return t;
  }
  
  terminal& clreol(terminal& t){
    t.clreol();
    return t;
  }
  
  terminal& clrbol(terminal& t){
    t.clrbol();
    return t;
  }
  
  terminal& clrln(terminal& t){
    t.clrln();
    return t;
  }
  
  terminal& normal(terminal& t){
    t.normal();
    return t;
  }
  
  terminal& bold(terminal& t){
    t.bold();
    return t;
  }
  
  terminal& reverse(terminal& t){
    t.reverse();
    return t;
  }
  
  terminal& underline(terminal& t){
    t.underline();
    return t;
  }
  
  terminal& savecur(terminal& t){
    t.savecur();
    return t;
  }
  
  terminal& restcur(terminal& t){
    t.restcur();
    return t;
  }
  
  terminal& operator<<(terminal& term, const char* data){
    std::cout << data << std::flush;
    return term;
  }
  
  terminal& operator<<(terminal& term, const std::string& data){
    std::cout << data << std::flush;
    return term;
  }
  
  terminal& operator<<(terminal& term, const char data){
    std::cout << data << std::flush;
    return term;
  }


  /*********************************************************/
  /* Följande rader är till för versionshanteraren RCS     */
  const char* terminal_star85_cc_rcsid="$Id: terminal.cc,v 1.16 2003/02/02 19:01:04 jozef Exp $";
  std::string terminal::version(){
    return std::string(terminal_star85_cc_rcsid);
  }

  /*$Log: terminal.cc,v $
   *Revision 1.16  2003/02/02 19:01:04  jozef
   *Städat bort varningar från gcc-3.2
   *
   *Revision 1.15  2003/02/02 18:55:49  jozef
   *Lagt till en kommentar
   *
   *Revision 1.14  2003/02/02 17:12:31  jozef
   *Lagt in att markören sparas vid början av en semigrafisk operation och
   *återställs vid slutet
   *
   *Revision 1.13  2003/01/29 19:03:15  jozef
   *Ändrat esc-sekvenser för Home och End för xterm (igen)
   *
   *Revision 1.12  2003/01/29 15:38:45  jozef
   *Rättat upprepad defaultargumentvärde i definitioner (gcc-2.95 tillät det)
   *
   *Revision 1.11  2002/02/14 11:27:53  jozef
   *Fixat buggen att getNextEvent() returnerade koordinaterna i fel ordning
   *
   *Revision 1.10  2002/02/11 18:38:20  jozef
   *Rättat till ännu ett fel...
   *
   *Revision 1.9  2002/02/11 18:37:25  jozef
   *Rättat till ett smärre fel
   *
   *Revision 1.8  2002/02/11 18:35:28  jozef
   *Rättat felaktigt include-direktiv
   *
   *Revision 1.7  2002/02/11 18:29:30  jozef
   *Omskriven i sin helhet i C++. Klassen terminal och hjälpfunktioner nu
   *i namnrymden terminal_star85. Lagt in stöd för Linux-konsol, ändrat
   *förändringar av fkey-tabellen för specifika terminaltyper.
   *
   *Revision 1.6  2000/01/09 13:06:19  jozef
   *Anpassat till headerfilen som anpassats till MS Windows-versionen
   *
   *Revision 1.5  2000/01/08 16:58:53  jozef
   *Lagt till konvertering till terminal::Keycodes i getNextEvent()
   *som krävdes av gcc-2.95.2
   *
   *Revision 1.4  1998/12/07 13:53:22  jozef
   *Adderat glömd retur i terminal& scrollup()
   *
   *Revision 1.3  1998/01/02 11:25:44  jozef
   **** empty log message ***
   *
   *Revision 1.2  1997/12/23 18:26:31  jozef
   *- lagt till dtterm-funktionalitet
   *- lagt till void table() för tabellutskrift
   *- lagt till en template för operator<< för att kunna
   *  använda terminalobjektet som cout
   *
   // Revision 1.1  1997/01/08  04:55:10  jozef
   // Initial revision
   //*/
  /*                 Slut på versionshanterarrader         */
  /*********************************************************/
  
} // namespace terminal_star85