scripttableviewer.cxx

Go to the documentation of this file.

//
// Copyright 2010, 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.
//
// Warning:  not all files in this directory structure are covered by the
// same copyright.  Some of them are part of the GNU source distribution
// and you must obey the GPL copyright for those files.

#include <cxxtls/scripttableviewer.h>
#include <ctype.h>
#include <cxxtls/viewermanager.h>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <cxxtls/strtool.h>
#include <cxxtls/file.h>
#include <portable_io.h>
#include <ctype.h>
#include <cxxtls/fmtd.h>

using namespace std;

namespace cxxtls
{


#ifdef _MSC_VER
    char const *discardErrors = " 2>nul:";
#else
    char const *discardErrors = " 2>/dev/null";
#endif


static void appendParm(string &output, string const &input, bool atEnd=true);


ScriptTableViewer::~ScriptTableViewer()
{
}
ScriptTableViewer::ScriptTableViewer(ViewerManager *vm, string const &scriptName, std::string directory)
: TableEditor(vm, '`')
, scriptname_(scriptName)
, keyKludge_(0)
, title_(application_name())
, directory_(directory)
{
    sessions_.push_back(SessionInfo());  // start cursor position plus options
    saveScreenLayout();                  // save the empty layout to be consistent
                                         // about pushing/popping the session info

    invocationKeys_.push_back(0x0a);  // ^J, \n:  the enter key triggers invocations of the
                                      // script using the current cell and row as parameters to it.
                                      // The script can add more items to the list by printing
                                      // =%==%--CMDKEYS=qQxX....
                                      // where 'q', 'Q', 'x', and 'X' are command keys that
                                      // the script accepts.  The script does not need to supply
                                      // the enter key, but if it did, it would use ^J to represent
                                      // the enter key, ^I for the tab key, etc.
                                      // Use ^^ to represent the ^ key.

    populateTable("");  // empty script session and contents is the highest level "state" of the script
                        // invocation tree
}


void ScriptTableViewer::handleReturnedCells()
{

   SessionInfo &caller = sessions_[ sessions_.size() -2 ];
   SessionInfo &popup  = sessions_.back();

   for(size_t i = 0; i < popup.returnedCells_.size(); ++i)
   {
      size_t row = popup.returnedCells_[i].first;
      size_t col = popup.returnedCells_[i].second;

      if(row < rows() && col < cols() )
      {
         char buffer[80];
         
         // row and col are zero based but users expect 1 based


         sprintf(buffer, "--CELL_VALUE_%d_%d", int(row+1), int(col+1));

         CellInfo const *cell = cellInfo(row,col);

         caller.commandLine_ = string(buffer) + 
                               "=" + 
                               "\"" + cell->text_[0] + "\" " + 
                               caller.commandLine_;

                 
      }

   }
}


bool ScriptTableViewer::handle_event( CursorWindow::input_event const * e,
                                CursorWindow::viewport          * vp
                              )
{
    if(    e->type_ == CursorWindow::input_event::DataKey
       ||  e->type_ == CursorWindow::input_event::FunctionKey 
      )
    {
        // first, check to see if this is part 2 of a two part
        // command key sequence.  Part 1 is always ^X,

        if(keyKludge_)
        {
            keyKludge_ = false;

            switch(e->value_)
            {
                case 0x03: // ^X^C quit editing
                   return true;

                case 0x0b: // ^X^K quit editing

                    if(sessions_.size() > 1)
                    {
                       handleReturnedCells();

                       sessions_.pop_back();
                       restoreSavedScreenLayout();
                       restartSession(vp);
                    }
                    else
                       return true;  // when out of sessions, quit

                case 0x17: // ^X^W  
                    snatchEdit(vp, directory_);
                    return false;    
                

                default: vp->beep(); break;
            }

            return false;
        }

        // ok, this is not part two a two part key sequence


        switch(e->value_)
        {
           case 0x18:  // ^X
           {
              keyKludge_ = true;
           }
           return false;


           case 0x10: // ^P
           {
               pageRight(vp);
           }
           return false;

           case 0x11: // ^Q
           {
               pageLeft(vp);
           }
           return false;

           case 0x09: // TAB
           {
               moveRight(vp);
           }
           return false;

           case CursorWindow::key_btab: // shift tab
           {
               moveLeft(vp);
           }
           return false;


           case 'q':
           case 'Q':
           {
               // if we are in an editable

               CursorInfo cursor = cursorInfo();

               if(   rows_.size() > cursor.row_ 
                  && cols_.size() > cursor.col_
                 )
               {
                  if(fieldEditable(cursor))
                  {
                     break; // current field is editable, so don't pop out
                            // of the current page -- rather insert the q
                            // into field text by dropping out the
                            // switch statement.
                  }
               }


               // if we get here, the field is not editable, so tree
               // q like a command (like ^X^K, to be precise)

               if(sessions_.size() > 1)
               {
                  handleReturnedCells();

                  sessions_.pop_back();
                  restoreSavedScreenLayout();
                  restartSession(vp);
               }
               else
                  return true;  // when out of sessions, quit

               return false;

           }
           break;

           case 0x1b:
           {
               if(sessions_.size() > 1)
               {
                  handleReturnedCells();
                  sessions_.pop_back();
                  restoreSavedScreenLayout();
                  restartSession(vp);
               }
               else
                  return true;  // when out of sessions, quit
           }
           return false;

           case 0x0d: // \r carriage return
           case 0x0a: // \a newline  enter
           {

               CursorInfo cursor = cursorInfo();

               if( fieldExecutable(cursor) )
               {
                     // only editable fields are executable...

                     sessions_.back().startCursorPosition_ = cursor;
     
                     sessions_.push_back( sessions_.back() ); // duplicate back session
                     saveScreenLayout();
     
                     invokeCommand(vp, 0x0a);
     
               }
               else
               {
                  vp->beep();
               }


           }
           return false;


           default:
           {
               CursorInfo cursor = cursorInfo();

               if( !fieldEditable(cursor) && fieldExecutable(cursor) )
               {



                   if( find(invocationKeys_.begin(), invocationKeys_.end(), e->value_) != invocationKeys_.end())
                   {
                       sessions_.back().startCursorPosition_ = cursorInfo();
    
                       sessions_.push_back( sessions_.back() ); // duplicate back session
                       saveScreenLayout();
    
                       invokeCommand(vp, e->value_);

                       return false; // don't send the key to the table editor
    
                   }
    
               }

               break;
           }

        }
    }

   // by default, act like a table viewer -- which has different arrow key behavior
   // than is inforced here

   bool quitNow = false;
   
   quitNow = TableEditor::handle_event(e,vp);  // perform edit, but ignore quit logic

   quitNow = quitNow; // suppress compiler warning for unused variables.

   if(e->type_ == CursorWindow::input_event::ForceExitKey)
     return true; // don't ignore forced exits!

   return false;  // don't quit
}


std::string const &ScriptTableViewer::application_name() const
{
   static string app_name("TableCommander");

   return app_name;
}
std::string ScriptTableViewer::description() const
{
   return "Script Results Viewer";
}

Viewer* ScriptTableViewer::app(ViewerManager*vm, std::string &fullname)
{
  if(fullname.size() == 0)
  {
    CursorWindow::Dialog d("full script pathname");

    d += new CursorWindow::Dialog::String("name",
                                          "path",
                                          "*",
                                          40
                                         );
                                
    if(d.popup(vm->window()))
      return 0;

    fullname = d.element_value("name");

    if(fullname == "")
      return 0;


    FileName tmp(fullname);
    tmp.convert_to_absolute_path();

    fullname = tmp;

  }

  int delimiter=',';

  size_t dotPos = fullname.find_last_of('.');

  if(dotPos < fullname.size())
  {
    ++dotPos;  // get to 't' or 'c'

    if( dotPos < fullname.size())
    {
        if(fullname[dotPos] == 't' || fullname[dotPos] == 'T')
           delimiter=0x09; // tab  
    }
  }

  return new ScriptTableViewer(vm,fullname);
}

void
ScriptTableViewer::
help()
{

  std::auto_ptr< std::list< std::string > >
  viewer_help( new std::list< std::string > );

  viewer_help->push_back(string("Help for script:  ") + scriptname_);
  viewer_help->push_back("");

  string command = scriptname_ + " --HELP=1";

  if(!sessions_.empty())
  {
     std::map<std::string,std::string>::iterator state = sessions_.back().options_.find("STATE");

     if(state != sessions_.back().options_.end())
     {
       command += " --STATE=";
       command += state->second;
     }
  }

  


  FILE *scriptOutput = popen(command.c_str(), "r");

  bool helpHandledByScript=false;

  if(scriptOutput)
  {
      char buffer[2048];

      buffer[0] = 0;

      while(fgets(buffer, 2048, scriptOutput))
      {
        if( 0 == memcmp(buffer, "help:", 5) )
        {
            char *eol = strchr(buffer, '\n');

            if(eol)
            {
              *eol = 0;  // remove the trailing \n.
            }

            helpHandledByScript=true;

            string tabExpandedText;

            tabExpandedText = StrTool::expand_tabs(buffer+5);

            viewer_help->push_back(tabExpandedText);

            buffer[0] = 0;
        }
        else
            break;


      }

      pclose(scriptOutput);

      viewer_help->push_back("");
  }


  if(!helpHandledByScript)
  {
      viewer_help->push_back("  Script command keys:");
      viewer_help->push_back("    Enter Key    -- invoke command on current cell");
    
      if(invocationKeys_.size() > 1)
      {
         for(size_t i = 1; i < invocationKeys_.size(); ++i)
         {
             char buffer[256];
    
             char keyname[40];
    
             int  c = invocationKeys_[i];
    
             if(c < ' ')
             {
               sprintf(keyname, "^%c", c + '@');
             }
             else
             {
               sprintf(keyname, "%c", c);
             }
    
    
             sprintf(buffer, "    %-9.9s   -- interpreted by script", keyname);
    
             viewer_help->push_back(buffer);
         }
      }
  }

  viewer_help->push_back("");
  viewer_help->push_back("  Movement keys");
  viewer_help->push_back("    up arrow    -- move up one cell");
  viewer_help->push_back("    down arrow  -- move down one cell");
  viewer_help->push_back("    left arrow  -- move left 1 character or cell");
  viewer_help->push_back("                   if at the beginning of the cell");
  viewer_help->push_back("    right arrow -- move right 1 character or cell");
  viewer_help->push_back("                   if at the end of text in the cell");
  viewer_help->push_back("    tab         -- move right one cell");
  viewer_help->push_back("    shift-tab   -- move left one cell");
  viewer_help->push_back("    ^P          -- move right 1 whole page");
  viewer_help->push_back("");
  viewer_help->push_back("  Command invocation:");
  viewer_help->push_back("    Enter       -- trigger the action for this cell");

  manager_->help_helper(*viewer_help);
}


static void parseReturnedCells(string const &cellList,
                               vector< pair<size_t,size_t> > &returnData
                              )
{
    // expecting to process value which looks like this:
    //
    //   (rowNumber,colNumber), (rowNumber,colNumber), ...
    //
    //  row col pairs are stored in session_.back().returnedCells_;

    char const *ptr = cellList.data();
    char const *end = ptr + cellList.size();

    while(ptr != end)
    {
       // scan until you find a (

       while(ptr != end && *ptr != '(')
          ++ptr;

       if(ptr != end)
       {
           // if not out of data, try parsing (n,n)

           ++ptr;

           char const *start = ptr;

           while(ptr != end && *ptr != ')')
             ++ptr;

           if(ptr != end)
           {
              // scan to ptr should be "number,number)" with optional spaces.

              // cells are 1 based to users

              ++ptr;

              int row = -1;
              int col = -1;

              sscanf(start, " %d , %d ", &row, &col);

              if(row <= 0 || col <= 0)
                break;

              pair<size_t, size_t> tmp(row-1,col-1);

              returnData.push_back(tmp);

           }
       }
    }
}

void ScriptTableViewer::populateTable(std::string const      &scriptParms,
                                      CursorWindow::viewport *vp
                                     )
{

    string command = scriptname_ + " " + scriptParms + discardErrors;

    char saved_dir[2048];

    if(0 == getcwd(saved_dir, sizeof(saved_dir)))
    {
        saved_dir[0] = 0;
    }

    int err;

    if(!directory_.empty())
       err =chdir(directory_.c_str());

    FILE *scriptOutput = popen(command.c_str(), "r");

    err = chdir(saved_dir);

    if(!scriptOutput)
    {
       fileError_="script invocation failure:  ";
       fileError_+= command;
       return;
    }

    clear(); // delete all rows and columns.  But not the session_ contents!

    string line;

    bool firstLine=true;   // we have not yet passed the first line of row/col data.

    size_t rowCount=0, colCount=0;

    bool firstOption=true; // first option to be processed

    char buffer[32768];

    while(fgets(buffer, sizeof(buffer), scriptOutput))
    {
        if(firstOption && vp)
        {
           // on the very first line of output from the script, check to see if
           // we are dealing with a popup request.

           firstOption = false;

           // looking for =%==%--POPUP=

           size_t buffLength = strlen(buffer);

           if(buffLength > 13 && buffer[0] == '=')
           {
               static string POPUP="=%==%--POPUP=";


               if(strncmp(POPUP.c_str(), buffer, POPUP.size()) == 0)
               {
                  // OK, the script has produced =%==%--POPUP=<definition>
                  // as its output.

                  // so show the popup, and re-invoke the script with additional
                  // parameters defined by the user's inputs from the popup.

                  vector< pair<string, string> >  userInputs;

                  bool aborted = showPopup(vp, buffer, userInputs);

                  if(aborted)
                  {
                      userInputs.clear();

                      userInputs.push_back( pair<string,string>() );

                      userInputs.back().first  = "POPUP_ABORTED";
                      userInputs.back().second = "1";
                  }

                  string newParmList = scriptParms;

                  for(size_t i = 0; i < userInputs.size(); ++i)
                  {
                      string tmp = "--"; 
                      
                      tmp += userInputs[i].first;

                      tmp += '=';

                      tmp += userInputs[i].second;

                      appendParm(newParmList, tmp, false);  // prepend not append
                  }

                  // we have now added the user's popup selections to the
                  // the script invocation as variable settings.
                  // 
                 
                  pclose(scriptOutput);
                  
                  populateTable(newParmList, vp);

                  return;

               }
           }
        }


        FieldAttributes rowInfo;

        if(firstLine)
        {
            char c = buffer[0];

            // the original code included isprint(c) && isalnum(c)
            // as well as c >  ' ' && c > 0.
            //
            // Why in the world did I restrict this to printable
            // characters?  It interferes with C++ code appearing
            // in table cells.

            if(true
               && c != ' '  // can't use space as a delimiter
               && c != '='  // can't use equal as a delimiter
              )
            {
               delimiter_ = c;

               line = (buffer+1);
            }
            else
               line = buffer;
        }
        else
        {
            char *scan = buffer;

            rowInfo = FieldAttributes::skip(scan, (buffer+strlen(buffer)) );

            line = scan;
        }

        size_t lineSize = line.size();

        if(  lineSize 
           && line[ lineSize-1 ] == '\n')
        {
           line.erase(lineSize-1);  // remove trailing new line
        }

        if(firstLine && (line.size() > 5) && line[0] == '=')
        {
          // check to see if this really the first line or rather if we are in an
          // option line

          if(0 == memcmp("=%==%--", line.data(), 7) )
          {
             // ok, this is not a real line of input -- it is a option
             // sent to us by the script.  We are going to keep the option
             // and when we invoke the script the next time, we are going to
             // send the options back to the script as parameters on its command line


             string data( line.c_str() + 7 );

             size_t equalPt = data.find_first_of('=');

             if(equalPt < line.size())
             {
               // this line contains =%==%--name=value

               string name = data.substr(0, equalPt);

               string value( data.c_str() + equalPt+1 );

               map<string,string> &options = sessions_.back().options_;

               map<string,string>::iterator location = options.find(name);

               if(location == options.end())
                  options[name]=value;
               else
               {
                 location->second = value;
               }

               if( name == "TITLE")
               {
                  title_ = value;
               }
               else
               if( name == "CMDKEYS")
               {
                   // Store all the characters in the value part of the --CMDKEYS=value declaration
                   // as invocation keys.  Interpret ^J to be \n, etc.

                   string::const_iterator first = value.begin(), last = value.end();

                   while(first != last)
                   {
                       char c = *first++;

                       if(c == '^' && first != last)
                       {
                           // handle ^X style text

                           c = *first++;   // skip the ^ and look at the next character

                           if(c != '^')
                           {
                               if( islower(c) )
                                  c = tolower(c);

                               if(c >= 'A' && c <= 'Z')
                               {
                                  c -= '@';
                               }
                           }
                       }

                       if(find(invocationKeys_.begin(), invocationKeys_.end(), c) == invocationKeys_.end())
                       {
                           // if command key not already in the list, add it to the list
                           invocationKeys_.push_back(c);
                       }
                   }
               }
               else
               if( name == "POPUPRETURN")
               {
                   // expecting to process value which looks like this:
                   //
                   //   (rowNumber,colNumber), (rowNumber,colNumber), ...
                   //
                   //  row col pairs are stored in session_.back().returnedCells_;

                   parseReturnedCells(value, sessions_.back().returnedCells_);


               }


               continue;
             }
             break;

          }
        }


        StrTool::stringlist_t fields;

        StrTool::parse_words(line, 
                             &fields, 
                             StrTool::all, 
                             StrTool::Is_Delim(delimiter_)
                            );

        if(firstLine)
        {
            // if this is the first line, set up the column headers


            firstLine = false;

            StrTool::stringlist_t::const_iterator first = fields.begin(),
                                                  last  = fields.end();

            while(first != last)
            {
               string const &cur = *first++;

               char const *scan = cur.c_str();
               char const *end  = scan + cur.size();

               FieldAttributes colInfo = FieldAttributes::skip(scan, end); 

               // if there is a [x] string, then scan will now point past ].


               addColumnHeader(scan, end - scan, colInfo, true);

               ++colCount;
            }

        }
        else
        {
            char buffer[40];

            sprintf(buffer, "%lu", (unsigned long)rows()+1);

            addRow(buffer,
                   1,
                   rowInfo.underlined_, 
                   rowInfo.bold_, 
                   rowInfo.editable_,
                   rowInfo.executable_
                  );

            ++rowCount;

            StrTool::stringlist_t::const_iterator first = fields.begin(),
                                                  last  = fields.end();

            while(first != last)
            {
               string const &cur = *first++;

               addColumnData(cur);
            }



        }

    }

    err = pclose(scriptOutput);

    (void)err;

}

static void appendParm(string &outputRef, string const &input, bool atEnd)
{
   string *outputPtr = &outputRef;    // normally, append text to end of outputRef

   string tmp;

   if(!atEnd)
   {
       outputPtr = &tmp;   // if not storing at end, produce output to a temporary
                           // and prepend instead of appending
   }

   if(!(*outputPtr).empty())
     (*outputPtr) +=  " ";

   (*outputPtr) += "\"";

   string::const_iterator first = input.begin(), last = input.end();

   while(first != last)
   {
      char c = *first++;

      if(c == '"' || c == '`' || c == '$' )
        (*outputPtr) += "\\";

      (*outputPtr) += c;

   }

   (*outputPtr) += "\"";

   if(!atEnd)
   {
      tmp += ' ';
      
      tmp += outputRef;  // attach original data to end instead of vice versa

      outputRef = tmp;   // return whole data set
   }

}

void ScriptTableViewer::restartSession(CursorWindow::viewport *vp)
{
       bool repopulate=true;  // if not CXX_STV_REPOPULATE

       std::map<std::string,std::string>::iterator flagPtr = sessions_.back().options_.find("CXX_STV_REPOPULATE");

       if( flagPtr != sessions_.back().options_.end())
       {
           if(flagPtr->second == "0")
               repopulate=false;
       }



       if(repopulate)
           populateTable(sessions_.back().commandLine_);  

       operator()(vp,  CursorWindow::viewport::repaint_handler::activate);
          // the above paint call is required in order to calculate page
          // height so you can't optimize the following code by moving it
          // above the paint.

       if(   sessions_.back().startCursorPosition_.row_ < rows()
          && sessions_.back().startCursorPosition_.col_ < cols()
         )
       {
           if(    sessions_.back().startCursorPosition_.row_ < originRow()
              ||  (   sessions_.back().startCursorPosition_.row_  > originRow() + pageHeight_ )
             )
           {
              setOrigin(sessions_.back().startCursorPosition_.row_, 0);

              operator()(vp,  CursorWindow::viewport::repaint_handler::activate);

           }

           TableViewer::setCursorInfo(vp, sessions_.back().startCursorPosition_);
       }

}


void ScriptTableViewer::invokeCommand(CursorWindow::viewport *vp, int cmdKey)
{
   char keyname[40];

   if(cmdKey < ' ')
   {
      sprintf(keyname, "^%c", '@' + cmdKey);
   }
   else
   {
       sprintf(keyname, "%c", cmdKey);
   }


   if(rows())
   {

       string &parms = sessions_.back().commandLine_;

       parms.resize(0);  // empty out any old data.

       CursorInfo cursor = cursorInfo();

       map<string,string>::iterator firstOp = sessions_.back().options_.begin(), 
                                    lastOp  = sessions_.back().options_.end();

       while(firstOp != lastOp)
       {
          map<string,string>::value_type const &cur = *firstOp++;

          static string dashes("--");

          string option= dashes + cur.first + "=" + cur.second;


          appendParm(parms, option );
       }

       appendParm( parms, keyname);    
       appendParm( parms, string( fmtd<>(cursor.row_+1)) ); // row
       appendParm( parms, string( fmtd<>(cursor.col_+1)) ); // column
       appendParm( parms, string( fmtd<>(rows())       ) ); // total rows
       appendParm( parms, string( fmtd<>(cols())       ) ); // total columns

       if(layout_[cursor.row_][cursor.col_].text_.size())
       {
          // current cell text

          appendParm(parms, layout_[cursor.row_][cursor.col_].text_[0]); 
       }

       string rowText;

       vector<CellInfo>::const_iterator first = layout_[cursor.row_].begin(),
                                        last  = layout_[cursor.row_].end();

       while(first != last)
       {
          CellInfo const &cur = *first++;

          if(cur.text_.empty())
            parms += " \"\"";
          else
            appendParm(parms, cur.text_[0]);  // first row of cell

       }


       populateTable(parms,vp);

       operator()(vp,  CursorWindow::viewport::repaint_handler::activate);


   }

}
void ScriptTableViewer::repaintTitle(CursorWindow::viewport *vp)
{
  vp->set_curpos(0,0);
  vp->set_text_attribute(active() ?  manager_->active_title_att
                                  :  manager_->inactive_title_att
                        );
                        
  *vp << title_;

  vp->fill_to_eol();
}

bool ScriptTableViewer::showPopup(CursorWindow::viewport        *vp, 
                                  string const                  &encodedDefinition,
                                  vector< pair<string,string> > &userInputs
                                 )
{
    string definition;  // upon entry, the encodedDefinition has '!hh' character sequences
                        // in it.  They must be expanded into normal ascii by 
                        // converting 'hh' into a hex rep of the character

    // decode the definition by expanding !hh

    size_t i = encodedDefinition.find_first_of('-');  // --POPUP=

    i = encodedDefinition.find_first_of('=',i);  // find the =

    if(i < encodedDefinition.size() )
      ++i;  // skip past the =

    for(; i < encodedDefinition.size(); ++i)
    {
       if( encodedDefinition[i] == '!')
       {
           ++i;

           if(i < encodedDefinition.size() )
           {
              char c[3];

              c[2] = 0;

              c[0] = encodedDefinition[i];

              ++i;

              if( i < encodedDefinition.size() )
              {
                 c[1] = encodedDefinition[i];

                 int charValue=0;

                 sscanf(c, "%x", &charValue);

                 if(charValue)
                 {
                    definition += charValue;
                 }
                 else
                 {
                    definition += '!';
                    definition += c[0];
                    definition += c[1];
                 }

              }
              else
              {
                 definition += '!';
                 definition += c;
              }

           }
           else
               definition += '!';
       }
       else
       if(encodedDefinition[i] >= ' ')
       {
          definition += encodedDefinition[i];
       }
       else
       {
         // ignore tabs and other special characters
       }
    }

    // Definition now contains the real definition which is of the form:
    //
    //   --POPUP=title; label1 ; value 1; label2 ; value 2;
    //
    // 
    // The user's selections will be returned in order:
    //
    //     name="POPUP_FIELD_1"
    //     value"user entry 1
    //
    //     name="POPUP_FIELD_2"
    //     value"user entry 2
    
    userInputs.clear();

    
    // get the title

    string title="title";

    i = definition.find_first_of(';');

    if(i >= definition.size())
    {
       return true; // title must end in ;
    }

    title = definition.substr(0, i);

    // remove the title from the definition

    definition = definition.substr(i+1, definition.size()- i - 1);

    CursorWindow::Dialog dialog(title);

    int fieldNumber=0;

    while(definition.size())
    {
       // extract label/value pairs

       string label;
       string value;

       // get label.  labels must be ; terminated.

       i = definition.find_first_of(';');

       if( i >= definition.size())
       {
         return true; // badly formed label/value pair
       }

       // remove the label from definition

       label = definition.substr(0,i);

       definition = definition.substr(i+1, definition.size()- i - 1);

       i = definition.find_first_of(';');

       bool done = false;

       if( i >= definition.size() )
       {
          // call the rest of the definition the value

          value = definition;

          done = true;

       }
       else
       {
           value = definition.substr(0, i);
           
           definition = definition.substr(i+1, definition.size() - i - 1);

           if(definition.find_first_of(';') >= definition.size())
           {
              done = true;
           }
          
       }

       // here we have label and value

       char fieldName[40];
       
       sprintf(fieldName, "POPUP_FIELD_%d", ++fieldNumber);

       userInputs.push_back(  pair<string,string>() );

       userInputs.back().first = fieldName;

       dialog += new CursorWindow::Dialog::String(fieldName,
                                                  label,
                                                  value,
                                                  40
                                                 );


       if(done)
         break;

    }


    // ok, if we get here we have found no errors in the definition


    dialog += new CursorWindow::Dialog::Ok("ok","");

    if(dialog.popup(vp->window()))
    {
      return true; // aborted
    }

    // now populate the return data

    for(i = 0; i < userInputs.size(); ++i)
    {
       userInputs[i].second = dialog.element_value(userInputs[i].first);
    }

    
    return false;  // no errors
}

} // namespace cxxtls