unix_curses.h

Go to the documentation of this file.

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.


#include <cxxtls/cursorwindow.h>
#include <cxxtls/sequence_map.h>
#include <string>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <algorithm>
#include <cxxtls/file.h>
#include <cxxtls/user.h>
#include <cxxtls/machine.h>
#include <iostream>
#include <fstream>
#include <portable_io.h>

#include <cxxtls/cursesinterface.h>


extern "C"
{
#ifndef _XOPEN_SOURCE_EXTENDED
#define _XOPEN_SOURCE_EXTENDED
#endif

#define NOMACROS
#include <curses.h>

#undef clear
int clear();

}

#include <term.h>
#include <termios.h>

namespace cxxtls
{


namespace CursesInterface
{
  bool screen_resize_occurred=0;


#ifdef _MSC_VER
  mouse_info read_mouse_info() { return mouse_location(0,0,0); } // not yet implemented
#endif

  long line_chars[lcCOUNT];

  char* _map_kf1  ;  // global variables holding function key sequences
  char* _map_kf2  ;  // obtained from the term.h header file after the
  char* _map_kf3  ;  // terminal is opened.
  char* _map_kf4  ;
  char* _map_kf5  ;
  char* _map_kf6  ;
  char* _map_kf7  ;
  char* _map_kf8  ;
  char* _map_kf9  ;
  char* _map_kf10 ;
  char* _map_kf11 ;
  char* _map_kf12 ;
  char* _map_khom ;
  char* _map_kend ;
  char* _map_kic  ;
  char* _map_kdc  ;
  char* _map_kpr  ;
  char* _map_knx  ;
  char* _map_kup  ;
  char* _map_kdn  ;
  char* _map_klf  ;
  char* _map_krt  ;
  char* _map_kbtab;

  void map_init_key_strings()
  {
     _map_kf1  = key_f1;
     _map_kf2  = key_f2;
     _map_kf3  = key_f3;
     _map_kf4  = key_f4;
     _map_kf5  = key_f5;
     _map_kf6  = key_f6;
     _map_kf7  = key_f7;
     _map_kf8  = key_f8;
     _map_kf9  = key_f9;
     _map_kf10 = key_f10;
     _map_kf11 = key_f11;
     _map_kf12 = key_f12;
     _map_khom = key_home;
     _map_kend = key_end;
     _map_kic  = key_ic;
     _map_kdc  = key_dc;
     _map_kpr  = key_ppage;
     _map_knx  = key_npage;
     _map_kup  = key_up;
     _map_kdn  = key_down;
     _map_klf  = key_left;
     _map_krt  = key_right;
     _map_kbtab= key_btab;


  }

typedef Sequence_Map<char,int> SEQMAP;
typedef SEQMAP::search         SEARCH;
typedef SEQMAP::sequence       SEQUENCE;

SEQMAP key_sequences;

void insert_key_sequence(char const *s, int code)
{
   if(s == 0)
     return;

   SEQUENCE seq(key_sequences, code);

   while(*s)
   {
      seq += *s++;
   }

   seq.complete();

}

void create_key_sequences_map();


sigset_t winch_blocker;  // holds 'SIGWINCH' flag (window change signal)

void make_xterm_terminfo_file(FileName const &dir);


#ifdef __linux
static bool quit_occurred;
static bool susp_occurred;
static bool int_occurred;

  extern "C"
  {
    static void quit_handler(int)
    {
      quit_occurred=1;
      signal(SIGQUIT, quit_handler); // re-enable signal
    }
  }

  extern "C"
  {
    static void susp_handler(int)
    {
      susp_occurred=1;
      signal(SIGTSTP, susp_handler); // re-enable signal
    }
  }


  extern "C"
  {
    static void int_handler(int)
    {
      int_occurred=1;
      signal(SIGINT, int_handler); // re-enable signal
    }
  }




#endif


void openCursesTerminal()
{
#ifdef __linux
  quit_occurred = false;
  susp_occurred = false;
  int_occurred  = false;
#endif

  if(getenv("WAIT_FOR_DEBUGGER"))
  {
     printf("waiting for debugger to attach and single step this program\n");

     int stop=1;

     while(stop)
     {
        sleep(1);
     }

  }

static bool first_time=true;
if(first_time)
{ // begin environment settings

  first_time =false;


  char const *termname = getenv("TERM");

  if(   termname == 0 
     || (   termname[0] != 'x'
         && termname != std::string("cygwin")
        )
    )
  {
    std::cerr << "Error, right now I only support TERM=xterm" << std::endl;
    exit(1);
  }

  UserInfo me = UserInfo::get();

  if(me.name_ == "")
  {
    std::cerr << "Error, couldn't get user id info -- system error" << std::endl;
    exit(1);
  }

  FileName tooldir = me.home_dir_ + "/.tools_home";

  if( !tooldir.is_dir() )
  {
    // need to create the tools TERMINFO files

    if(tooldir.mkdir())
    {
      std::cerr << "Error, couldn't create " << tooldir << std::endl;
      exit(1);
    }

  }

  MachineInfo host = MachineInfo::get();

  if(host.hostname_ == "")
  {
    std::cerr << "Error, couldn't get hostname" << std::endl;
    exit(1);
  }

  FileName hostdir = tooldir + "/" + host.hostname_;

  if(!hostdir.is_dir())
  {
    // need to create host specific terminfo

    if(hostdir.mkdir())
    {
      std::cerr << "Error, couldn't create " << hostdir << std::endl;
      exit(1);
    }

  }

  make_xterm_terminfo_file(hostdir);

  FileName terminfodir  = hostdir;
           terminfodir += "/terminfo";

  if(!terminfodir.is_dir())
  {
    // need to create host specific terminfo

    if(terminfodir.mkdir())
    {
      std::cerr << "Error, couldn't create " << terminfodir << std::endl;
      exit(1);
    }

  }

  FileName xterm_info_file  = terminfodir;
           xterm_info_file += "/x/xterm";

  std::string command("TERMINFO=");

              command += terminfodir;
              command += " ";
              command += "/usr/bin/tic ";
              command += hostdir + "/xterm.info";

  if(!xterm_info_file.exists())
  {
    int err = system(command.c_str());

    (void)err;
  }

  if(!xterm_info_file.exists())
  {
    //  the xterm.info file did not get created.
    //  Normally this is an error but on suse linux, SLES to be precise, the 
    //  /usr/bin/tic program has a bug in it that causes it to write on the
    //  system directories and ignore the TERMINFO environment variable.
    //  SO, the root user on SLES cannot get past this without hand creating the link.
    // 

    int uid = getuid();

    if(uid == 0)
    {
        command="mkdir -p " + terminfodir + "/x" + "\n";

        int rc;

        rc = system(command.c_str());

        command="ln -s /usr/share/terminfo/x/xterm " + xterm_info_file + "\n"; 
        
        rc = system(command.c_str());

        rc=rc;
        
    }

      if(!xterm_info_file.exists())
      {
        std::cerr << "Error, command '" << command << "', did not create" << std::endl
                  << "file " << xterm_info_file << std::endl;
      
        exit(1);
      }
  }

  static char * envstring=0;

  std::string tmp1("TERMINFO=");
              tmp1 += terminfodir;
        
  char const *tmp2 = tmp1.c_str();

  int l = strlen(tmp2);

  envstring = new char[l+1];

  strcpy(envstring, tmp2);

  putenv(envstring);

} // end environment settings



  initscr();

  raw();
  noecho();
  meta(stdscr, TRUE);

  halfdelay(10);

  intrflush(stdscr,FALSE);
  keypad(stdscr,TRUE);
  typeahead(0);  /* tells refresh() to check for pending input() */


  #ifdef __linux


    static struct termios override_termios;

    tcgetattr(0, &override_termios);
      
    cfmakeraw(&override_termios);

    override_termios.c_cc[VQUIT]=0;
    override_termios.c_cc[VSUSP]=0;

    override_termios.c_cc[VMIN]=1;
    override_termios.c_cc[VTIME]=10;

    tcsetattr(0, TCSANOW, &override_termios);

  #else

    termios io_info;


    tcgetattr(0, &io_info);

    io_info.c_cc[VMIN]=1;
    io_info.c_cc[VTIME]=10;
    tcsetattr(0, TCSANOW, &io_info);


  #endif


  // block the sigwinch signal

  sigemptyset(&winch_blocker);

  sigaddset(&winch_blocker, SIGWINCH);

  sigprocmask(SIG_BLOCK, &winch_blocker, 0);



  siginterrupt(SIGWINCH, true);
  siginterrupt(SIGALRM, true);

#ifdef __linux
  siginterrupt(SIGQUIT, true);
  siginterrupt(SIGTSTP, true);
  siginterrupt(SIGINT,  true);
#endif

  map_init_key_strings();
  create_key_sequences_map();

  using namespace CursesInterface;

  line_chars[UL_CORNER] = ACS_ULCORNER;
  line_chars[LL_CORNER] = ACS_LLCORNER;
  line_chars[UR_CORNER] = ACS_URCORNER;
  line_chars[LR_CORNER] = ACS_LRCORNER;
  line_chars[HL_MIDDLE] = ACS_HLINE;
  line_chars[VL_MIDDLE] = ACS_VLINE;
  line_chars[PL_BOX   ] = ACS_PLUS;
  line_chars[TE_LEFT  ] = ACS_LTEE;
  line_chars[TE_RIGHT ] = ACS_RTEE; 
  line_chars[TE_BOTTOM] = ACS_BTEE;
  line_chars[TE_TOP   ] = ACS_TTEE;

}

void closeCursesTerminal()
{
            attrset(0);
            clear();
            refresh();
            endwin();
            #ifdef __linux
            resetterm();
            #endif

    if(screen_resize_occurred)
    {
       // make sure the screen is empty

       for(int i = 0; i < 100; ++i)
       {
          std::cout << "\n";
       }

    }

}

#undef key_up
#undef key_down
#undef key_left
#undef key_right
#undef key_sup
#undef key_sdown
#undef key_sleft
#undef key_sright
#undef key_prior
#undef key_next
#undef key_ic
#undef key_dc
#undef key_home
#undef key_end
#undef key_btab
#undef key_f1
#undef key_f2
#undef key_f3
#undef key_f4
#undef key_f5
#undef key_f6
#undef key_f7
#undef key_f8
#undef key_f9
#undef key_f10
#undef key_f11
#undef key_f12
#undef erase

int mapCursesKey(int curses_key)  // map to CursorWindow key representation
{
  switch(curses_key)
  {
    case KEY_UP:    return CursorWindow::key_up;
    case KEY_DOWN:  return CursorWindow::key_down;
    case KEY_LEFT:  return CursorWindow::key_left;
    case KEY_RIGHT: return CursorWindow::key_right;
    case KEY_SLEFT: return CursorWindow::key_sleft;
    case KEY_SRIGHT:return CursorWindow::key_sright;
    case KEY_PPAGE: return CursorWindow::key_prior;
    case KEY_NPAGE: return CursorWindow::key_next;
    case KEY_IC:    return CursorWindow::key_ic;
    case KEY_DC:    return CursorWindow::key_dc;
    case KEY_HOME:  return CursorWindow::key_home;
    case KEY_SHOME: return CursorWindow::key_home;
    case KEY_END:   return CursorWindow::key_end;
    case KEY_BTAB:  return CursorWindow::key_btab;


    #ifdef __linux
    case 0x7f:      return CursorWindow::key_bs;
    case KEY_BACKSPACE: return CursorWindow::key_bs;
    #endif
                
    case KEY_F(1):  return CursorWindow::key_f1;
    case KEY_F(2):  return CursorWindow::key_f2;
    case KEY_F(3):  return CursorWindow::key_f3;
    case KEY_F(4):  return CursorWindow::key_f4;
    case KEY_F(5):  return CursorWindow::key_f5;
    case KEY_F(6):  return CursorWindow::key_f6;
    case KEY_F(7):  return CursorWindow::key_f7;
    case KEY_F(8):  return CursorWindow::key_f8;
    case KEY_F(9):  return CursorWindow::key_f9;
    case KEY_F(10): return CursorWindow::key_f10;
    case KEY_F(11): return CursorWindow::key_f11;
    case KEY_F(12): return CursorWindow::key_f12;
  }

  return curses_key;
}



void getCursesCursor(int *row, int *col)
{
   getyx(stdscr, *row, *col);
}

void getCursesScreenSize(int *row, int *col)
{
   getmaxyx(stdscr, *row, *col);
}


// A_STANDOUT      000010000000
// _STANDOUT       A_STANDOUT    /* for compatability with old curses */
// A_UNDERLINE     000020000000
// A_REVERSE       000040000000
// A_BLINK         000100000000
// A_DIM           000200000000
// A_BOLD          000400000000
// A_ALTCHARSET    001000000000

void setCursesAttributes( int a )
{
  // 'a' is assumed to be a CursorWindow attribute

  int att=0;

  switch(a)
  {
    case   CursorWindow::reversed:
      att = A_REVERSE;
      break;

    case   CursorWindow::underlined:
      att = A_UNDERLINE;
      break;

    case   CursorWindow::blinking:
      att = A_BLINK;
      break;

    case   CursorWindow::bold:
      att = A_BOLD;
      break;

    case   CursorWindow::reverse_ul:
      att = A_REVERSE | A_UNDERLINE;
      break;

    case   CursorWindow::reverse_bold:
      att = A_REVERSE | A_BOLD;
      break;

    case   CursorWindow::rev_ul_bold:
      att = A_REVERSE | A_UNDERLINE | A_BOLD;
      break;

    case   CursorWindow::bold_ul:
      att = A_UNDERLINE | A_BOLD;
      break;



    default:
      break;
  }

  (void)attrset(att);

}


void paintCharString(char const *r, int count, int a, int row, int col)
{
    setCursesAttributes(a);

    while(count--)
        {
            int c = *r++;

            if(c < ' ' ||  (c & 0xff) > 0x7f)
            {
              c = '`';
            }

            mvaddch(row, col++, c);
        }
}

void paintCharString(long c, int count, int a, int row, int col)
{
    if(c < ' ' ||  (c & 0xff) > 0x7f)
    {
      c = '`';
    }

    setCursesAttributes(a);

    while(count--)
        {
            mvaddch(row, col++, c);
        }
}



void refreshCursesWindow()
{
  refresh();
}

void beepCursesTerminal()
{
  beep();
}


void moveCursesCursor(int row, int col)
{
  move(row,col);
}


void make_xterm_terminfo_file(FileName const &dir)
{
  FileName filename = dir;
           filename += "/xterm.info";

  if(filename.exists())
    return;

  std::fstream f(filename.c_str(), std::ios::out);

  if(f.bad())
  {
    std::cerr << "Error creating file " << filename << std::endl;
    exit(1);
  }

#ifdef LINUX
  char const *terminfo =
"#       Reconstructed via infocmp from file: /usr/share/terminfo/x/xterm                                  \n"
"xterm|xterm terminal emulator (X Window System),                                                          \n"
"        am, bce, km, mc5i, mir, msgr, xenl,                                                               \n"
"        colors#8, cols#80, it#8, lines#24, pairs#64,                                                      \n"
"        acsc=``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,                                        \n"
"        bel=^G, blink=\\E[5m, bold=\\E[1m, cbt=\\E[Z, civis=\\E[?25l,                                     \n"
"        clear=\\E[H\\E[2J, cnorm=\\E[?25h, cr=^M,                                                         \n"
"        csr=\\E[%i%p1%d;%p2%dr, cub=\\E[%p1%dD, cub1=^H,                                                  \n"
"        cud=\\E[%p1%dB, cud1=^J, cuf=\\E[%p1%dC, cuf1=\\E[C,                                              \n"
"        cup=\\E[%i%p1%d;%p2%dH, cuu=\\E[%p1%dA, cuu1=\\E[A,                                               \n"
"        cvvis=\\E[?25h, dch=\\E[%p1%dP, dch1=\\E[P, dl=\\E[%p1%dM,                                        \n"
"        dl1=\\E[M, ech=\\E[%p1%dX, ed=\\E[J, el=\\E[K, el1=\\E[1K,                                        \n"
"        enacs=\\E(B\\E)0, flash=\\E[?5h$<100/>\\E[?5l, home=\\E[H,                                        \n"
"        hpa=\\E[%i%p1%dG, ht=^I, hts=\\EH, ich=\\E[%p1%d@, ich1=\\E[@,                                    \n"
"        il=\\E[%p1%dL, il1=\\E[L, ind=^J, invis=\\E[8m,                                                   \n"
"        is2=\\E[!p\\E[?3;4l\\E[4l\\E>, kBEG=\\EOu, kDC=\\EOn,                                             \n"
"        kEND=\\EOq, kHOM=\\EOw, kIC=\\EOp, kLFT=\\EOt, kNXT=\\EOr,                                        \n"
"        kPRV=\\EOx, kRIT=\\EOv, ka1=\\EOH, ka3=\\E[5~, kb2=\\EOE,                                         \n"
"        kbeg=\\EOE, kbs=\\177, kc1=\\EOF, kc3=\\E[6~, kcub1=\\EOD,                                        \n"
"        kcud1=\\EOB, kcuf1=\\EOC, kcuu1=\\EOA, kdch1=\\E[3~, kend=\\EOF,                                  \n"
"        kent=\\EOM, kf0=\\E[21~, kf1=\\E[11~, kf10=\\E[21~,                                               \n"
"        kf11=\\E[23~, kf12=\\E[24~, kf13=\\E[25~, kf14=\\E[26~,                                           \n"
"        kf15=\\E[28~, kf16=\\E[29~, kf17=\\E[31~, kf18=\\E[32~,                                           \n"
"        kf19=\\E[33~, kf2=\\E[12~, kf20=\\E[34~, kf21=\\E[35~,                                            \n"
"        kf22=\\E[36~, kf3=\\E[13~, kf4=\\E[14~, kf5=\\E[15~, kf54=\\EOo,                                  \n"
"        kf55=\\EOj, kf56=\\EOm, kf57=\\EOk, kf58=\\EOl, kf6=\\E[17~,                                      \n"
"        kf7=\\E[18~, kf8=\\E[19~, kf9=\\E[20~, kfnd=\\E[1~, khome=\\EOH,                                  \n"
"        kich1=\\E[2~, kind=\\EOs, kmous=\\E[M, knp=\\E[6~, kpp=\\E[5~,                                    \n"
"        kri=\\EOy, kslt=\\E[4~, mc0=\\E[i, mc4=\\E[4i, mc5=\\E[5i,                                        \n"
"        op=\\E[39;49m, rc=\\E8, rev=\\E[7m, ri=\\EM, rmacs=^O,                                            \n"
"        rmam=\\E[?7l, rmcup=\\E[?1047l\\E[?1048l, rmir=\\E[4l,                                            \n"
"        rmkx=\\E[?1l\\E>, rmso=\\E[27m, rmul=\\E[24m,                                                     \n"
"        rs1=\\Ec\\E[?67;9l, rs2=\\E[!p\\E[?3;4l\\E[4l\\E>, sc=\\E7,                                       \n"
"        setab=\\E[4%p1%dm, setaf=\\E[3%p1%dm,                                                             \n"
"        setb=\\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,                     \n"
"        setf=\\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,                     \n"
"        sgr=\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;, \n"
"        sgr0=\\E[m\\017, smacs=^N, smam=\\E[?7h,                                                          \n"
"        smcup=\\E[?1048h\\E[?1047h, smir=\\E[4h, smkx=\\E[?1h\\E=,                                        \n"
"        smso=\\E[7m, smul=\\E[4m, tbc=\\E[3g, u6=\\E[%i%d;%dR,                                            \n"
"        u7=\\E[6n, u8=\\E[?1;2c, u9=\\E[c, vpa=\\E[%i%p1%dd,                                              \n"
;

#else
  char const *terminfo =
"#       Reconstructed via infocmp from file: /usr/share/lib/terminfo/x/xterm             \n"
"xterm|vs100|lowells extended xterm terminal emulator,                                    \n"
"        am, km, mir, msgr, xenl,                                                         \n"
"        cols#80, it#8, lines#65,                                                         \n"
"        acsc=``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,                         \n"
"        bel=^G, blink=\\E[5m, bold=\\E[1m, clear=\\E[H\\E[2J,                            \n"
"        cr=\\r, csr=\\E[%i%p1%d;%p2%dr, cub=\\E[%p1%dD, cub1=\\b,                        \n"
"        cud=\\E[%p1%dB, cud1=\\n, cuf=\\E[%p1%dC, cuf1=\\E[C,                            \n"
"        cup=\\E[%i%p1%d;%p2%dH, cuu=\\E[%p1%dA, cuu1=\\E[A,                              \n"
"        dch=\\E[%p1%dP, dch1=\\E[P, dl=\\E[%p1%dM, dl1=\\E[M,                            \n"
"        ed=\\E[J, el=\\E[K, el1=\\E[1K$<3>, enacs=\\E(B\\E)0,                            \n"
"        home=\\E[H, ht=\\t, hts=\\EH, ich=\\E[%p1%d@, ich1=\\E[@,                        \n"
"        il=\\E[%p1%dL, il1=\\E[L, ind=\\n, ka1=\\EOq, ka3=\\EOs,                         \n"
"        kb2=\\EOr, kbs=\\b, kc1=\\EOp, kc3=\\EOn, kcub1=\\EOD,                           \n"
"        kcud1=\\EOB, kcuf1=\\EOC, kcuu1=\\EOA, kent=\\EOM,                               \n"
"        kf1=\\E[11~,                                                                     \n"
"        kf10=\\E[21~,                                                                    \n"
"        kf2=\\E[12~,                                                                     \n"
"        kf3=\\E[13~,                                                                     \n"
"        kf4=\\E[14~,                                                                     \n"
"        kf5=\\E[15~,                                                                     \n"
"        kf6=\\E[17~,                                                                     \n"
"        kf7=\\E[18~,                                                                     \n"
"        kf8=\\E[19~,                                                                     \n"
"        kf9=\\E[20~,                                                                     \n"
"        rc=\\E8,                                                                         \n"
"        rev=\\E[7m,                                                                      \n"
"        khome=\\E[1~,                                                                    \n"
"        kend=\\E[4~,                                                                     \n"
"        kll=\\E[E;,                                                                      \n"
"        kpp=\\E[5~,                                                                      \n"
"        knp=\\E[6~,                                                                      \n"
"        kich1=\\E[2~,                                                                    \n"
"        kf11=\\E[23~,                                                                    \n"
"        kf12=\\E[24~,                                                                    \n"
"        kcbt=\\E[TAB;,                                                                   \n"
"        kLFT=\\E[LEFT;,                                                                  \n"
"        kRIT=\\E[RIGHT;,                                                                 \n"
"        kPRV=\\E[prior;,                                                                 \n"
"        kNXT=\\E[next;,                                                                  \n"
"        kdch1=\\177,                                                                    \n"
"        ri=\\EM, rmacs=^O, rmkx=\\E[?1l\\E>, rmso=\\E[m,                                 \n"
"        rmul=\\E[m,                                                                      \n"
"        rs1=\\E>\\E[1;3;4;5;6l\\E[?7h\\E[m\\E[r\\E[2J\\E[H, rs2=@,                       \n"
"        sc=\\E7,                                                                         \n"
"        sgr=\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t^N%e^O%;, \n"
"        sgr0=\\E[m, smacs=^N, smkx=\\E[?1h\\E=, smso=\\E[7m,                             \n"
"        smul=\\E[4m, tbc=\\E[3g,                                                         \n"
"        kHOM=\\E[H,                                                                      \n"
"        kEND=\\E[E,                                                                      \n"
;
#endif

   f.write(terminfo, strlen(terminfo));

   if(f.bad())
   {
     std::cerr << "Error creating " << filename << std::endl;
     exit(1);
   }

   f.close();

   std::cerr << "\n\n\n\n"
             << "Since this is the first time you have run this program as this\n"
             << "user on this host, the special purpose curses TERMINFO database\n"
             << "is created for you in \n\n  " 
             << dir 
             << "/xterm.info\n\n"
             << "If you wish to change the keyboard bindings used by curses\n"
             << "You can edit that file then remove\n\n  "
             <<  dir
             << "terminfo/x/xterm\n\n"
             << "to get the database automatically rebuilt the next\n"
             << "you run this program.\n\n"
             ;

   std::cerr << "Press enter to continue:" << std::endl;
   std::cerr.flush();
   std::cin.get();

   std::cerr << "\n\n\n\n"
             << "You should have received documentation about configuring\n"
             << "curses with this program.  If you have a source distribution\n"
             << "look in the etc sub-directory directory for a README file.\n\n"
             << "If you are using an X windows emulator you will need to\n"
             << "make sure that your emulator passes the Home, End, Page Up,\n"
             << "and Page Down keys through as a string not as functions!\n"
             << "You'll also want to make the backspace key send ^H not ^?\n"
             << "and perhaps modify your shell startup to use \n\n  "
             << "stty erase '^H'\n\n"
             ;

   std::cerr << "Press enter to continue:" << std::endl;
   std::cerr.flush();
   std::cin.get();

   std::cerr << "\n\n\n\n"
             << "Note:  you should have received an Xterm file which is used\n"
             << "by X windows to define key bindings for your xterm program.\n"
             << "If you choose not use the one provided, you must ensure that\n"
             << "all the function keys you like using are set up in both\n"
             << "$HOME/Xterm and $HOME/.tools_dir/<OS>/xterm.info.\n\n"
             << "If your keys still don't work after making sure of all the\n"
             << "above, check to see if you are setting your xmodmap key bindings\n"
             << "in some way that conflicts with Xterm and xterm.info.\n\nGood luck!\n\n"
             ;


   std::cerr << "Press enter to continue:" << std::endl;
   std::cerr.flush();
   std::cin.get();

}




  void create_key_sequences_map()
  {
    insert_key_sequence(CursesInterface::_map_kf1  , CursorWindow::key_f1);
    insert_key_sequence(CursesInterface::_map_kf2  , CursorWindow::key_f2);
    insert_key_sequence(CursesInterface::_map_kf3  , CursorWindow::key_f3);
    insert_key_sequence(CursesInterface::_map_kf4  , CursorWindow::key_f4);
    insert_key_sequence(CursesInterface::_map_kf5  , CursorWindow::key_f5);
    insert_key_sequence(CursesInterface::_map_kf6  , CursorWindow::key_f6);
    insert_key_sequence(CursesInterface::_map_kf7  , CursorWindow::key_f7);
    insert_key_sequence(CursesInterface::_map_kf8  , CursorWindow::key_f8);
    insert_key_sequence(CursesInterface::_map_kf9  , CursorWindow::key_f9);
    insert_key_sequence(CursesInterface::_map_kf10 , CursorWindow::key_f10);
    insert_key_sequence(CursesInterface::_map_kf11 , CursorWindow::key_f11);
    insert_key_sequence(CursesInterface::_map_kf12 , CursorWindow::key_f12);
    insert_key_sequence(CursesInterface::_map_khom , CursorWindow::key_home);
    insert_key_sequence(CursesInterface::_map_kend , CursorWindow::key_end);
    insert_key_sequence(CursesInterface::_map_kic  , CursorWindow::key_ic);
    insert_key_sequence(CursesInterface::_map_kdc  , CursorWindow::key_dc);
    insert_key_sequence(CursesInterface::_map_kpr  , CursorWindow::key_prior);
    insert_key_sequence(CursesInterface::_map_knx  , CursorWindow::key_next);
    insert_key_sequence(CursesInterface::_map_kup  , CursorWindow::key_up);
    insert_key_sequence(CursesInterface::_map_kdn  , CursorWindow::key_down);
    insert_key_sequence(CursesInterface::_map_klf  , CursorWindow::key_left);
    insert_key_sequence(CursesInterface::_map_krt  , CursorWindow::key_right);
    insert_key_sequence(CursesInterface::_map_kbtab, CursorWindow::key_btab);

    {
      static char extra_home [] = { 0x1b, '[', 'H', 0 };
      static char extra_end  [] = { 0x1b, '[', 'F', 0 };
      static char extra_btab [] = { 0x1b, '[', 'Z', 0 };

      insert_key_sequence(extra_home,  CursorWindow::key_home);
      insert_key_sequence(extra_end,   CursorWindow::key_end);
      insert_key_sequence(extra_btab,  CursorWindow::key_btab);


      #ifdef __linux
      static char extra_bs   [] = { 0x7f, 0 };
      insert_key_sequence(extra_bs,    CursorWindow::key_bs);
      #else
      static char extra_dc   [] = { 0x7f, 0 };
      insert_key_sequence(extra_dc,    CursorWindow::key_dc);

      static char extra_dc1   [] = { 0x1b, '[', '3', '~', 0 };
      insert_key_sequence(extra_dc1,    CursorWindow::key_dc);

      static char extra_bs   [] = { 0x008, 0 };
      insert_key_sequence(extra_bs,    CursorWindow::key_bs);
      #endif

    }

    {
      static char extra_home1[] = { 0x1b, 'O', 'H', 0 };
      static char extra_end1 [] = { 0x1b, 'O', 'F', 0 };
      static char extra_btab1[] = { 0x1b, 'O', 'Z', 0 };


      insert_key_sequence(extra_home1, CursorWindow::key_home);
      insert_key_sequence(extra_end1,  CursorWindow::key_end);
      insert_key_sequence(extra_btab1, CursorWindow::key_btab);
    }


    {
      static char extra_f1[] = { 0x1b, 'O', 'P', 0 };
      static char extra_f2[] = { 0x1b, 'O', 'Q', 0 };
      static char extra_f3[] = { 0x1b, 'O', 'R', 0 };
      static char extra_f4[] = { 0x1b, 'O', 'S', 0 };
      static char extra_end  [] = { 0x1b, '[', 'E', 0 };

      insert_key_sequence(extra_f1,  CursorWindow::key_f1);
      insert_key_sequence(extra_f2,  CursorWindow::key_f2);
      insert_key_sequence(extra_f3,  CursorWindow::key_f3);
      insert_key_sequence(extra_f4,  CursorWindow::key_f4);
      insert_key_sequence(extra_end,  CursorWindow::key_end);
    }


    {
      static char extra_home1[] = { 0x1b, '[', '1', '~', 0 };
      static char extra_end1 [] = { 0x1b, '[', '4', '~', 0 };

      insert_key_sequence(extra_home1, CursorWindow::key_home);
      insert_key_sequence(extra_end1,  CursorWindow::key_end);
    }


    {
      SEARCH search(key_sequences);

      if(!search(0x1b))
      {
        closeCursesTerminal();
        printf("couldn't find the Esc key in the sequence!");
        exit(1);
      }
      ++search;

      if(!search('['))
      {
        closeCursesTerminal();
        printf("couldn't find the '[' key in the!");
        exit(1);
      }
      ++search;

      if(!search('H'))
      {
        closeCursesTerminal();
        printf("couldn't find the 'H' sequence!");
        exit(1);
      }
      ++search;

      int code=0;

      if(!search.finished(&code))
      {
        closeCursesTerminal();
        printf("couldn't find the home sequence!");
        exit(1);
      }

      if(code != CursorWindow::key_home)
      {
        closeCursesTerminal();
        printf("wrong key code returned");
        exit(1);
      }

    }


  }


  int alarm_occurred=0;

  int read_key_char()
    // return a 'char' to the user -- or a 0 that indicates the alarm
    // timer fired.
  {
    char buffer[1];

      while(winch_occurred == 0      &&
            read(0, &buffer, 1) < 1  &&
            alarm_occurred == 0      
#ifdef __linux
            &&
            quit_occurred == 0       &&
            susp_occurred == 0       &&
            int_occurred  == 0
#endif
           )
      {
        usleep(100000);  // sleep 1/10 of a second
      }


    if(alarm_occurred)
    {
      alarm_occurred = 0;
      return 0;
    }

    if(winch_occurred)
    {
        return -1;
    }

    alarm_occurred=0;

#ifdef __linux
    if(quit_occurred)
    {
      quit_occurred=0;
      buffer[0] = 0x1c;  // control backslash
    }

    if(susp_occurred)
    {
      susp_occurred=0;
      buffer[0] = 0x1a;  // control backslash
    }

    if(int_occurred)
    {
      int_occurred=0;
      buffer[0] = 3;   // ^C
    }
#endif


    return buffer[0];

  }


#undef refresh

  extern "C" void alarm_handler(int signum)
  {
     alarm_occurred=1;
     signal(SIGALRM, alarm_handler);
  }

  extern "C"
  {
    static void sigwinch_handler(int)
    {
      winch_occurred=1;
      screen_resize_occurred=true;
    }
  }


  static std::string _saved;

  int read_mapped_key(CursorWindow &w)
    //
    // read a key from the keyboard and handle function key sequences
    //
  {

    if(_saved.size())
    {
       // keys have been pushed back in the algorithm below
       // and we are reading the saved values in subsequent reads

       int rv = _saved[0];

       _saved.erase(_saved.begin());

       return rv;
    }

    if(resize_requested)
      return -1;

    refresh();

    signal(SIGWINCH, sigwinch_handler);

    signal(SIGALRM, alarm_handler);

#ifdef __linux
    signal(SIGQUIT, quit_handler);
    signal(SIGTSTP, susp_handler);
    signal(SIGINT, int_handler);
#endif

    SEARCH search_term = key_sequences;


    int c;

    int code;


    for(;;)
    {
      sigprocmask(SIG_UNBLOCK, &winch_blocker, 0); // enable window change signals

      c = read_key_char();


      sigprocmask(SIG_BLOCK, &winch_blocker, 0); // disable window change signals

      if(c == 0x1b)
      {
         // escape is never the middle character in a sequence
         alarm_occurred=0;
         ualarm(900000,0);  // cause the next read to type out
                            // the timeout is 0.9 seconds.  ualarm on UBUNTU
                            // malfunctions for 1.0 and higher...

      }
      else
      {
         ualarm(0,0);  // turn off any pending alarm

      }

      if(winch_occurred || resize_requested || c == -1)
      {
        _saved.resize(0);
        
        closeCursesTerminal();
        openCursesTerminal();
        refresh();
        
        return -1;
      }

      if( c == 0  || !search_term(c) )
      {
        // either we have a read time out or this key isn't part of
        // a valid sequence

        if(c == 0x1b)
        {
          // escape is never found in the middle of a sequence
        
          if( _saved.size() && _saved[0] == 0x1b )
          {
            // discard the previous sequence and let this start a new one
        
            SEARCH new_term = key_sequences;
        
            new_term(c);

            ++new_term;
        
            search_term = new_term;
        
            _saved.resize(0);
            _saved += (char)(0x1b);

            continue;
        
          }
        
        }

        if(c != 0)
          _saved += (char)(c);

        if(_saved.size())
        {
          int rv = _saved[0];

          _saved.erase(_saved.begin());

          return rv;
        }

        continue;  // if no chars read, keep reading
      }

      ++search_term;

      _saved += (char)(c);

      if(search_term.finished(&code))
      {
        _saved.resize(0);
        return code;
      }
    }

  }

};

} // namespace cxxtls