texteditor.cxx

Go to the documentation of this file.

//
// Copyright 2002-2012, 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.

//@file
//

#include <cxxtls/options.h>
#include <texteditor.hxx>
#include <cxxtls/viewermanager.h>
#include <cxxtls/skiprope.h>
#include <fstream>
#include <portable_strstream.h>
#include <cxxtls/strtool.h>
#include <map>
#include <memory.h>
#include <cxxtls/strtool.h>
#include <algorithm>
#include <portable_io.h>
#include <cxxtls/etagsdb.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <cxxtls/simple_regex.h>
#include <cxxtls/cursesinterface.h>
#include <cxxtls/foreach.h>
#include <cxxtls/cpptagdb.h>
#include <cxxtls/muSED.h>
#include <fstream>


using namespace cxxtls;

typedef CursorWindow::row_col     row_col;
typedef CursorWindow::viewport    viewport;
typedef viewport::repaint_handler repaint_handler;
typedef CursorWindow::input_event input_event;


struct EditLine
{

  //  Only one of the folllowing 2 pointers will be non-null

  std::string *original_data_;   
  std::string *modified_data_;   

  bool crRemoved_; 


  EditLine(std::string* original_data)
  :  original_data_(original_data),
     modified_data_(0),
     crRemoved_(0)
  {
  }

  ~EditLine()
  {
    // does nothing, you are responsible for deleting the data yourself.
    // that saves an extraneous copy construction everywhere
  }

  std::string* data()
  {
    return original_data_ ? original_data_ : modified_data_;
  }

  operator std::string()
  {
    if(original_data_)
      return StrTool::expand_tabs(*original_data_);
    else
      return *modified_data_;

  }

  void replace(std::string const &s)
  {
    if(original_data_)
      delete original_data_;

    original_data_ = 0;

    if(modified_data_)
      delete modified_data_;

    modified_data_ = new std::string(s);
  }

  std::string &maybe_tabbify()
  {
    static std::string rv;

    if(original_data_)
      return *original_data_;

    rv = StrTool::pack_tabs(*modified_data_);

    return rv;
  }



};

typedef skiprope<EditLine>        rep_type;   // edit session representation


struct TextIterator
{
   int           line_;    // line number we are talking about
   std::string   text_;    // text of a line in the edit session
   size_t        length_;  // length of text_
   size_t        col_;     // column within text_ (can be same as length!)
   rep_type&     rep_;     // the container of lines

   TextIterator(TextIterator const& r)
   : line_(r.line_),
     text_(r.text_),
     length_(r.length_),
     col_(r.col_),
     rep_( const_cast<rep_type&>(r.rep_))
   {
   }

   void operator=(TextIterator const &r)
   {
     line_   = r.line_;
     text_   = r.text_;
     length_ = r.length_;
     col_    = r.col_;
     
     if(&rep_ != &r.rep_)
     {
        // fatal error -- the two must be compatible!
     }

   }


   TextIterator(rep_type &rep, int line, size_t column)
   : line_(line),
     col_(column),
     rep_(rep)
   {
     if(line < rep.size())
       text_ = rep[line];
     else
       text_ = "";

     length_ = text_.size();
   }

   void correct_overruns() // called after incrementing the col_
   {
     if(col_ > length_)  // NOT ">="  !
     {
        col_ = 0;
        
        ++line_;
        
        if(line_ >= rep_.size())
        {
          line_ = rep_.size();
          text_ = "";
        }
        else
        {
          text_ =  rep_[line_];
        }
        
        length_ = text_.size();
        
     }
   }

   void correct_underruns() // called after decrementing the col_
   {
     if(col_ >= length_)    // yes >= (and length_ is an unsigned!
     {
        
        --line_;
        
        if(line_ < 0)
        {
          line_ = 0;
          text_ = "";
        }
        else
        {
          text_ =  rep_[line_];
        }
        
        length_ = text_.size();
        col_ = length_;     // yes, past the end of line so the operator* will
                            // return '\n'
                        
        
     }
   }


   char operator*() 
   {
     return col_ >= length_ ? '\n' : text_[col_];
   }


   TextIterator &operator++ ()
   {
     ++col_;

     correct_overruns();

     return *this;
   }


   TextIterator operator++ (int )
   {
     TextIterator rv= *this;
     ++col_;
     correct_overruns();
     return rv;
   }

   TextIterator &operator-- ()
   {
     --col_;

     correct_underruns();

     return *this;
   }


   TextIterator operator-- (int )
   {
     TextIterator rv= *this;
     --col_;
     correct_underruns();
     return rv;
   }

   bool operator==( TextIterator const &r )
   {
     return col_ == r.col_ && line_ == r.line_;
   }

   bool operator!=( TextIterator const &r )
   {
     return col_ != r.col_ || line_ != r.line_;
   }

};


struct UndoOperation
{
   enum ActionToTake
   {
      replace_line,
      insert_line,
      erase_line,
      join_lines,       // created when you split
      insert_block,
      delete_block,
      replace_block,
      break_lines,      // created when you join
      nested_undo_ops,  // replace all strings' uses this to treat the undoing
                        // all changes in a single operation
                        
                        
                        
      last_code         // MUST BE LAST!
   };

   int code_;          // action to take
   int count_;         // of lines in a deleted block

   std::string text_;  // to replace_with

   int lineno_;        // line number upon which to act

   std::list<std::string> block_;  // block of lines to insert at lineno_


   typedef std::list<UndoOperation*> undo_stack;

   undo_stack *nested_undo_stack_;  // replace_first()

   int nested_first_mark_; // only valid if using the nested undo stack
   int nested_last_mark_;

private: 

   void* operator new(size_t t)
   {
     return new char[t];
   }

public:

   void operator delete(void *p)
   {
     char *cp = (char*)(p);

     delete[] cp;
   }

   static UndoOperation* make_new()
     // don't call this -- it is meant only
     // to be used by Impl::push_undo_stack()
   {
     return new UndoOperation;  
   }

};


struct TextEditor::Impl
{
  FileName fullname_;       
  int      left_;           
  bool     active_;         
  int      first_row_;      
  int      page_top_;       
  size_t   page_left_;      

  int      cur_;            
  int      first_mark_;     
  int      last_mark_;      

  size_t   col_;            

                        
  int      bottom_line_;    

  size_t   htab_;           
  bool     use_tabs_;       

  size_t   left_margin_;    


  rep_type lines_;  

  std::string word_chars_; 

                        
  std::string search_text_; 
  std::string replacement_; 
  bool        is_regex_;    
  SimpleRegex regexp_;      

  bool key_kludge_;  

                
  bool word_kludge_; 

  bool is_writeable_; 

  bool is_new_;       
                
  UndoOperation::undo_stack  undo_stack_;  

  bool is_dirty_; // are there unsaved edit changes

  UndoOperation* push_undo_stack()
  {
    UndoOperation*rv = UndoOperation::make_new();

    undo_stack_.push_front(rv);

    is_dirty_ = true;

    return rv;
  }


  ViewerManager* manager_;


  bool fetchAllLines(std::list<std::string> &outout); 

  int      size() { return lines_.size(); } 


  void     display_line(viewport* vp, int line);

  void     read_file(); 


  void  paint_page(viewport* vp, Viewer *v) { (*v)(vp, 0); }

  void  restore_cursor(viewport* vp)
  {
    vp->set_curpos(first_row_ + (cur_ - page_top_),
                   col_ - page_left_ + left_
                  );
  }

  void push_undo_line_change(int line, std::string const &old_text)
  {
    if(undo_stack_.begin() == undo_stack_.end())
    {
      // stack is empty, create the first element

      UndoOperation* op = push_undo_stack();

      op->code_   = UndoOperation::replace_line;
      op->text_   = StrTool::expand_tabs(old_text);
      op->lineno_ = line;


    }
    else
    {
      // the stack isn't empty, see if the most recent item is the
      // same as this item

      UndoOperation* op = undo_stack_.front();

      if(op->code_    != UndoOperation::replace_line ||
         op->lineno_  != line
        )
      {
        // this is a new one, so push it on the stack

        UndoOperation* op = push_undo_stack();
        
        op->code_   = UndoOperation::replace_line;
        op->text_   = old_text;
        op->lineno_ = line;
        

      }

    }

  }


  void replace_line(int line_no, std::string const &new_text, bool save_undo=true)
  {
     if(save_undo)
       push_undo_line_change(line_no, *line_text(line_no).data());

     lines_[line_no].replace(new_text);
  }

  rep_type::iterator line_address(int line_no)
  {
    return lines_.find(line_no);
  }

  void erase_line(rep_type::iterator location,
                  int                corresponding_line,
                  bool               save_undo_info = true
                 )
  {
    if(save_undo_info)
    {
      EditLine& line  = *location;

      UndoOperation *op = push_undo_stack();

      op->text_   = *line.data();
      op->lineno_ = corresponding_line;
      op->code_   = UndoOperation::insert_line;

    }

    lines_.erase(location);
  }


  EditLine& line_text(int line_no)
  {

    static EditLine empty( new std::string("") );

    if( line_no >= lines_.size())
    {
       return empty;
    }

    return lines_[line_no];
  }


  void  make_col_visible(viewport*, Viewer*);

  void  make_line_visible(viewport*, Viewer*, bool center=true);

  size_t vwidth(row_col &vp_size) { return vp_size.col_ - left_; }

  size_t vheight(row_col &vp_size) { return vp_size.row_ - first_row_; }

  bool  is_marked(int line) { return line >= first_mark_ && line < last_mark_; }

  typedef bool (Impl::*func_handler)(viewport*, Viewer*, input_event const *);

  static std::map<int, std::pair<func_handler, bool> > func;

  bool find_next_helper(viewport*, Viewer*, input_event const *);

  bool find_prev_helper(viewport*, Viewer*, input_event const *);

  bool replace_next_helper(viewport*, Viewer*, input_event const *);

  void save         (viewport*, TextEditor*, input_event const *);


  bool is_word_char(char c)
  {
    if(std::find( word_chars_.begin(), word_chars_.end(), c) == word_chars_.end())
      return false;

    return true;
  }

  //  The following functions return iterators into the edit session that will
  //  span lines -- don't modify the session by creating, deleting, or changing
  //  lines as this will invalidate the iterators.

  TextIterator top_pointer();  
  TextIterator cur_pointer();  
  TextIterator bot_pointer();  

  //
  // The following class, StringCompare, is a character comparison functor.  It is
  // meant to be used as a parameter to the std::search algoritm
  //

  bool mixed_case_;    // controls CharCompare
  bool match_words_;   // find and replace only whole words

  struct CharCompare
  {
    TextEditor::Impl* impl_;

    bool operator() (char a, char b) const
    {
        if(impl_->mixed_case_)
        {
          if( isupper(a) )
            a = tolower(a);
        
          if( isupper(b) )
            b = tolower(b);
        
          return a == b;
        }
        
        return a == b;
    }

    CharCompare(TextEditor::Impl* t)
    : impl_(t)
    {
    }

  };


  //
  // Declarations for the various editor member functions whose job is to
  // directly implement an edit command
  //
  bool page_down      (viewport*, Viewer*, input_event const *);
  bool page_up        (viewport*, Viewer*, input_event const *);
  bool char_left      (viewport*, Viewer*, input_event const *);
  bool char_right     (viewport*, Viewer*, input_event const *);
  bool char_matching  (viewport*, Viewer*, input_event const *);
  bool tab_right      (viewport*, Viewer*, input_event const *);
  bool tab_left       (viewport*, Viewer*, input_event const *);
  bool char_delprv    (viewport*, Viewer*, input_event const *);
  bool char_delete    (viewport*, Viewer*, input_event const *);
  bool char_insert    (viewport*, Viewer*, input_event const *);
  bool line_home      (viewport*, Viewer*, input_event const *);
  bool line_end       (viewport*, Viewer*, input_event const *);
  bool line_split     (viewport*, Viewer*, input_event const *);
  bool line_up        (viewport*, Viewer*, input_event const *);
  bool line_down      (viewport*, Viewer*, input_event const *);
  bool line_del       (viewport*, Viewer*, input_event const *);
  bool line_mark      (viewport*, Viewer*, input_event const *);
  bool line_clreol    (viewport*, Viewer*, input_event const *);
  bool line_goto      (viewport*, Viewer*, input_event const *);
  bool line_join      (viewport*, Viewer*, input_event const *);
  bool line_insert    (viewport*, Viewer*, input_event const *);
  bool file_top       (viewport*, Viewer*, input_event const *);
  bool file_bottom    (viewport*, Viewer*, input_event const *);
  bool file_insert    (viewport*, Viewer*, input_event const *);
  bool word_next      (viewport*, Viewer*, input_event const *);
  bool word_prev      (viewport*, Viewer*, input_event const *);
  bool word_delete    (viewport*, Viewer*, input_event const *);
  bool snatch_edit    (viewport*, Viewer*, input_event const *);
  bool show_symbols   (viewport*, Viewer*, input_event const *);
  bool word_sfind     (viewport*, Viewer*, input_event const *);
  bool find_first     (viewport*, Viewer*, input_event const *);
  bool find_next      (viewport*, Viewer*, input_event const *);
  bool find_prev      (viewport*, Viewer*, input_event const *);
  bool block_delete   (viewport*, Viewer*, input_event const *);
  bool block_copy     (viewport*, Viewer*, input_event const *);
  bool block_paste    (viewport*, Viewer*, input_event const *);
  bool block_insert   (viewport*, Viewer*, input_event const *);
  bool block_adjust   (viewport*, Viewer*, input_event const *);
  bool block_save     (viewport*, Viewer*, input_event const *);
  bool block_transform(viewport*, Viewer*, input_event const *); // use mused to change the block
  bool replace_first  (viewport*, Viewer*, input_event const *);
  bool replace_next   (viewport*, Viewer*, input_event const *);
  bool undo           (viewport*, Viewer*, input_event const *);
  bool etags_first    (viewport*, Viewer*, input_event const *);
  bool cpptags_first  (viewport*, Viewer*, input_event const *);
  bool tags_next      (viewport*, Viewer*, input_event const *);
  bool etags_all      (viewport*, Viewer*, input_event const *); // list all matching functions
  bool cpptags_all    (viewport*, Viewer*, input_event const *);
  bool to_edit        (viewport*, Viewer*, input_event const *);
  bool reread         (viewport*, Viewer*, input_event const *); // cannot be undone
  bool switch_source  (viewport*, Viewer*, input_event const *);

};

typedef TextEditor::Impl  Impl;  // to simplfy typing


std::map<int, std::pair<Impl::func_handler, bool> > Impl::func;
    // the mapping between CursorWindow::func_*
    // values and TextEditor command handlers.

const bool Modifying=   true;  // use as parm to AddMapping constructor
const bool NonModifying=false;

struct AddMapping
{
  AddMapping(int cmd, Impl::func_handler f, bool modifying)
  {
    Impl::func[cmd] = std::pair<Impl::func_handler, bool>(f, modifying);
  }
};

bool TextEditor::fetchAllLines(std::list<std::string> &output)
{
   if(impl_.get())
   {
      return impl_->fetchAllLines(output);
   }

   return false;
}


void
TextEditor::
operator() ( CursorWindow::viewport *     vp,
             int                          cmd
           )
{
  // WARNING:  do not save vp -- it gets deleted regularly!
  
  // get page size and origin

  row_col size    = vp->size();
  row_col origin  = vp->origin();

  int     avail_rows  = impl_->vheight(size);
  // determine if the page is active or not

  if(cmd == repaint_handler::activate)
    impl_->active_ = true;
  else
  if(cmd == repaint_handler::deactivate)
    impl_->active_ = false;

  // handle the page left margin

  if(origin.col_)
  {
    impl_->left_ = 1;

        
    for(int i=0; i < size.row_; ++i)
    {
      vp->set_curpos(i, 0);

      if(i == size.row_ -1 || i == 0)
       vp->set_text_attribute(CursorWindow::bold_ul);
      else
       vp->set_text_attribute(ViewerManager::inactive_mark_att);

      using namespace CursesInterface;

      vp->write(line_chars[VL_MIDDLE]);
    }

  }
  else
    impl_->left_ =0;

  // handle the title line

  vp->set_curpos(0, impl_->left_);
  vp->set_text_attribute(impl_->active_? ViewerManager::active_title_att
                                       : ViewerManager::inactive_title_att
                                       );
  if( impl_->is_new_ )
    vp->write("Creating ");
  else
  if( impl_->is_writeable_ )
    vp->write("Editing ");
  else
    vp->write("Reading ");


  if(size.col_ > 70 )
  {
      vp->write(impl_->fullname_.shorten(size.col_ - 8 - 26) );
  }
  else
      vp->write(impl_->fullname_.shorten(size.col_ - 8) );



  vp->fill_to_eol();

  // paint the body of the text

  if(impl_->cur_ - impl_->page_top_ >= avail_rows)
  {
     // current cursor row is not visible -- make ti be visible.

     impl_->page_top_ = impl_->cur_ - avail_rows/2;

     if(impl_->page_top_ < 0)
     {
        impl_->page_top_ = 0;
     }

  }


  int row = impl_->first_row_;

  int line = impl_->page_top_;

  impl_->bottom_line_ = line + avail_rows - 1 ;  // for bottom line highlighting

  int row_count = 0;

  while(line < impl_->size() && row_count < avail_rows )
  {
     vp->set_curpos(row, impl_->left_);
     impl_->display_line(vp, line);
     ++row;
     ++line;
     ++row_count;
  }


  // paint the lines after body of the text

  bool first=true;

  while(row < size.row_)
  {
    vp->set_curpos(row, impl_->left_);

    if(first)
    {
      vp->set_text_attribute(ViewerManager::active_title_att);
      vp->write("*eof*");
      vp->set_text_attribute(ViewerManager::normal_att);
      first = false;
    }
    else
    {
      if(row == size.row_ -1)
        vp->set_text_attribute(ViewerManager::bottom_att);
      else
        vp->set_text_attribute(ViewerManager::normal_att);
    }
    vp->fill_to_eol();

    ++row;
  }

  // place the cursor

  impl_->restore_cursor(vp);

}
                        
bool
TextEditor::
handle_event( input_event const * e,
              viewport          * vp
            )
{

  if(!impl_->is_writeable_)
  {
     // in view only mode, treat 'q' as an exit command

     if(e->type_ == CursorWindow::input_event::DataKey)
     {
        if(e->value_ == 'q' || e->value_ == 'Q')
        {
           return true;
        }
     }
  }


  if(e->type_ == CursorWindow::input_event::ForceExitKey)
  {
    return true;
  }

  bool rv = false;


  if(impl_->key_kludge_)
  {
    //
    // Most recent key was '^X', so handle the second key of a multi-key sequence
    // Note:  this is stupid.  I build a great mechanism for function key sequence
    // processing and I am not using it....
    //

    impl_->key_kludge_ = false;      // reset the ^X flag

    if(e->value_ == ('='))       // ^X = switches to the next source alternative
    {
      impl_->switch_source(vp,this,e);
    }
    else
    if(e->value_ == ('L'-'@'))       // ^X ^L rereads edit session
    {
      impl_->reread(vp,this,e);
    }
    else
    if(e->value_ == ('S' - '@'))     // ^X ^S saves the session
    {
      if(impl_->word_kludge_)
      {
        impl_->word_sfind(vp,this,e);
        impl_->word_kludge_ = false;
      }
      else
        impl_->save(vp,this,e);
    }
    else
    if(e->value_ == ('K' - '@') ||     // ^X ^K quits the session
       e->value_ == 'k'         ||     // ^X k quits the session
       0
      )
    {
      if(impl_->is_dirty_)
      {
        vp->beep();
        
        CursorWindow::Dialog d("Unsaved edit changes exist");
        d += new CursorWindow::Dialog::String("ok",
                                              "Quit Anyway (Yes or No)",
                                              "No",
                                              4
                                             );
        
        if(d.popup( manager_->window() ))
        {
          return false;
        }
        
        std::string ok_value = d.element_value("ok");
        
        if(ok_value.size() > 2)
        {
          ok_value.erase(2, ok_value.size());
        }
        
        if(ok_value != "Ye" && ok_value != "ye" )
        {
          vp->beep();
          return false;
        }
        
      }
      return true;
    }
    else
    if(e->value_ == ('G' - '@'))
      rv = impl_->line_goto(vp,this,e);
    else
    if(e->value_ == ('E' - '@'))
      rv= impl_->snatch_edit(vp,this,e);
    else
    if(e->value_ == ('W' - '@'))
    {
      impl_->key_kludge_ = true;   // if handling ^X, ignore ^W for the moment
      impl_->word_kludge_ = true;   // if handling ^X, ignore ^W for the moment
    }
    else
    if(e->value_ == '!')
    {
      impl_->etags_first(vp,this,e);
    }
    else
    if(e->value_ == '.')
    {
      impl_->cpptags_first(vp,this,e);
    }
    else
    if(e->value_ == '?')
    {
      impl_->etags_all(vp,this,e);
    }
    else
    if(e->value_ == '/')
    {
      impl_->cpptags_all(vp,this,e);
    }
    else
    if(e->value_ == ',')
    {
      impl_->tags_next(vp,this,e);
    }
    else
    if(e->value_ == ('A' - '@'))
    {
      impl_->key_kludge_ = true;   // if handling ^X, ignore ^A for the moment
      impl_->word_kludge_ = true;   // if handling ^X, ignore ^A for the moment
    }
    else
    if(e->value_ == ('I' - '@'))
    {
      impl_->block_insert(vp,this,e);  // ^X ^A ^I maps to 'insert text into block'
    }
    else
    if(e->value_ == ('B' - '@'))
    {
      impl_->block_adjust(vp,this,e);  // ^X ^A ^B maps to 'adjust block left and right'
    }
    else
    if(e->value_ == ('U' - '@'))
    {
      impl_->undo(vp,this,e); // ^X ^U is also undo.
    }
    else
    if(e->value_ == '0')
    {
      impl_->show_symbols(vp,this,e); // run cpptagdb.exe on this file and show the results
    }
    else
    if(e->value_ == ('R' - '@') )
    {
        impl_->file_insert(vp,this,e);
    }
    else
    if(e->value_ == ('O' - '@'))
    {
       impl_->block_save(vp,this,e);
    }
    else
    if(e->value_ == ('T' - '@'))
    {
       impl_->block_transform(vp,this,e);
    }

  }
  else
  {
    impl_->word_kludge_ = false;

    std::pair<Impl::func_handler, bool> map_entry = Impl::func[ CursorWindow::func[e->value_] ];

    Impl::func_handler f         =  map_entry.first;
    bool               modifying =  map_entry.second;


    if(f)
    {
       if(!impl_->is_writeable_ && modifying)
         vp->beep();
       else
         rv = (impl_.get()->*f)(vp, this, e);
    }
    else
    if(e->value_ == 0x1b)
    {
      vp->beep();  // this should bring up a command menu
    }
    else
    if(e->value_ == ('X' - '@'))
    {
      impl_->key_kludge_ = true;
    }
    else
      manager_->window()->beep();
  }

  if(rv == false)
  {
     char buffer[256];


     size_t lineOffset = impl_->cur_;
     size_t charOffset = impl_->col_;


//     char c = 0;
//     std::string line = impl_->line_text(lineOffset);
//
//     if(line.size() > charOffset)
//     {
//        c = line[charOffset];
//     }
//
//     snprintf(buffer, 256, "L=%d, C=%d, '\\0%o'", int(lineOffset+1), int(charOffset+1), c);


     snprintf(buffer, 256, "L=%-8d C=%-3d", int(lineOffset+1), int(charOffset+1));

     CursorWindow::row_col windowSize = vp->size();

     if(windowSize.col_ > 70)
     {
         
         vp->set_curpos(0, windowSize.col_ - 26);
         
         vp->set_text_attribute(impl_->active_? ViewerManager::active_title_att
                                              : ViewerManager::inactive_title_att
                               );
         vp->fill_to_eol();
         
         
         
         vp->set_curpos(0, windowSize.col_ - strlen(buffer));
         vp->write(buffer);
         
         impl_->restore_cursor(vp);
     }

  }


  return rv;
}

        
void
TextEditor::
help()
{
  typedef std::list<std::string> help_text;

  std::auto_ptr< help_text > viewer_help( new help_text );

  extern char const *editversion;

  std::string htext("Help for the text editor ");

  htext += editversion;

  viewer_help->push_back(htext);

  viewer_help->push_back("");

  viewer_help->push_back("(Use ^S to search)");

  viewer_help->push_back("");


  viewer_help->push_back("  In addition to the standard key bindings");
  viewer_help->push_back("  shown later, the text editor interprets");
  viewer_help->push_back("  the following parochial key bindings:");
  viewer_help->push_back("    ^X ^E -- edit the file whose name appears");
  viewer_help->push_back("             under the cursor");
  viewer_help->push_back("    ^X ^G -- goto specified line");
  viewer_help->push_back("    ^X ^S -- saves the edit session");
  viewer_help->push_back("    ^X ^K -- quits the edit session");
  viewer_help->push_back("    ^X  k -- quits the edit session");
  viewer_help->push_back("    ^X ^l -- rereads the file being edited, discarding changes");
  viewer_help->push_back("    ^X ^W ^E -- edit the file whose name appears");
  viewer_help->push_back("             under the cursor");
  viewer_help->push_back("    ^X ^W ^S -- find the next instance of the word under the cursor");
  viewer_help->push_back("    ^X  . -- Symbol name search (TAGPP.tagpp database)");
  viewer_help->push_back("    ^X  / -- All matching symbols searched (TAGPP.tagpp database)");
  viewer_help->push_back("    ^X  ! -- etags search FIRST matching symbol");
  viewer_help->push_back("    ^X  ? -- etags search ALL matching symbols");
  viewer_help->push_back("    ^X  , -- Search for next matching symbol");
  viewer_help->push_back("    ^X ^T -- Transform a block using SED commands:");
  viewer_help->push_back("             Note:  if any *.mused files are being edited,");
  viewer_help->push_back("             one of them will be selected as the script,");
  viewer_help->push_back("             otherwise, the user will be prompted for a 3 line script.");
  viewer_help->push_back("    ^X ^U -- undo (same as ^_ and ^?)");
  viewer_help->push_back("    ^X 0  -- show the symbols in the current file (only)");
  viewer_help->push_back("    ^X ^R -- read a file into the edit session");
  viewer_help->push_back("    ^X ^O -- write a selected block to a file.");
  viewer_help->push_back("");
  viewer_help->push_back("    ^X ^A ^I  -- insert column of text into");
  viewer_help->push_back("                 the currently marked block");
  viewer_help->push_back("    ^X ^A ^B  -- add or delete columns of");
  viewer_help->push_back("                 blanks to the current block");
  viewer_help->push_back("    F12  --  jump back and forth between source file variants:  .c, .h, etc");
  viewer_help->push_back("");
  viewer_help->push_back("  Special environment variables:");
  viewer_help->push_back("");
  viewer_help->push_back("   ETAGSPATH --  A ':' separated list of directories");
  viewer_help->push_back("                 in which to look for the TAGS file");
  viewer_help->push_back("                 which is used when looking for symbol definitions");
  viewer_help->push_back("                 and for source file alternates (.c/.h) -- see F12");
  viewer_help->push_back("                 EG:  .:..:/home/user");
  viewer_help->push_back("   SOURCEPATH--  A ':' separated list of directories and '*'s");
  viewer_help->push_back("                 in which to look for the source file alternates file");
  viewer_help->push_back("                 which is used when looking for symbol definitions");
  viewer_help->push_back("                 and for source file alternates (.c/.h) -- see F12");
  viewer_help->push_back("                 EG:  ..:/project/main/include:/project/main/src:/home/*");
  viewer_help->push_back("                 Searched when ^X ^E or ^X ^W ^E are pressed.");
  viewer_help->push_back("   SOURCEALTS--  A ':' separated list of file name extensions");
  viewer_help->push_back("                 which are used by the F12 key (switch source) to decide");
  viewer_help->push_back("                 how to find the alternative source file given the current");
  viewer_help->push_back("                 source file's name.  EG: .:.c:.h:.cc:.cxx:.cpp.  See F12");



  impl_->manager_->help_helper(*viewer_help);

}


TextEditor::
TextEditor(ViewerManager*vm, FileName fullname)
: Viewer(vm),
  impl_(new Impl)
{
  impl_->fullname_    = fullname;
  impl_->left_        = 0;
  impl_->active_      = false;
  impl_->first_row_   = 1;
  impl_->page_top_    = 0;
  impl_->page_left_   = 0;
  impl_->cur_         = 0;
  impl_->col_         = 0;
  impl_->htab_        = 8;      // changed when file read
  impl_->use_tabs_    = true;   // changed when file read
  impl_->bottom_line_ = 10000;  // an obviously invalid value
  impl_->first_mark_  = -1;
  impl_->last_mark_   = -1;     // pair of marked lines
  impl_->left_margin_ = 0;
  impl_->manager_     = vm;
  impl_->key_kludge_  = false;
  impl_->word_kludge_ = false;
  impl_->mixed_case_  = true;   // mixed case find string.
  impl_->match_words_ = false;  // only match whole words
  impl_->is_writeable_= true;   // true unless otherwise set to false by read_file
  impl_->is_new_      = false;  // set to true by read_file if file does not exist
  impl_->is_regex_    = false;  // not regex searches by default

  impl_->read_file();

  impl_->is_dirty_    = false;  // no unsaved edit changes exist yet

  {
    // define word characters

    std::string &word_chars = impl_->word_chars_;

    char c;

    word_chars += '_';

    for(c='a'; c <= 'z'; ++c) word_chars += c;
    for(c='A'; c <= 'Z'; ++c) word_chars += c;
    for(c='0'; c <= '9'; ++c) word_chars += c;
    word_chars += ':';

  }

}

TextEditor::
~TextEditor()
{
  rep_type::iterator first = impl_->lines_.begin(),
                     last  = impl_->lines_.end();
                
  while(first != last)
  {
    EditLine cur = *first++;

    delete cur.data();
  }
}

Viewer*
TextEditor::
app(ViewerManager*vm, std::string &fullname)
{
  if(fullname.size() == 0)
  {
#if 0
    CursorWindow::Dialog d("Edit File name");

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

    fullname = d.element_value("name");
#else
    CursorWindow::FileSelector d("Edit File Name", "*", "");

    fullname = d.popup(vm->window(), 0);

#endif

    if(fullname == "")
      return 0;


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

    fullname = tmp;

  }
  return new TextEditor(vm,fullname);

}

std::string
TextEditor::
app_name="TextEditor";

std::string
TextEditor::
description() const
{
  return impl_->fullname_;
}

bool
TextEditor::
is_dirty() const
{
  return impl_->is_dirty_;
}

void
Impl::
display_line(viewport* vp, int line)
{
  if(is_marked(line))
  {
    if(active_)
      vp->set_text_attribute(ViewerManager::highlighted_att);
    else
      vp->set_text_attribute(ViewerManager::inactive_mark_att);
  }
  else
  if(line == bottom_line_)
    vp->set_text_attribute(ViewerManager::bottom_att);
  else
    vp->set_text_attribute(ViewerManager::normal_att);


  if(line < size() )
  {
    std::string str = line_text(line);

    if(str.size() >= (size_t)(page_left_))
    {
      std::string::iterator first = str.begin() + page_left_,
                            last  = str.end();

      vp->write(first,last);
    }

  }

  vp->fill_to_eol();
}



AddMapping page_down_func(CursorWindow::func_next, &Impl::page_down, NonModifying);

bool
Impl::
page_down(viewport* vp, Viewer*v, input_event const *e)
{
  size_t page_offset = cur_ - page_top_;

  page_top_ += vp->size().row_ - first_row_;

  if(page_top_ >= size())
    page_top_ = size() -1;

  if(page_top_ < 0)
    page_top_ = 0;

  cur_ = page_top_ + page_offset;

  if(cur_ >= size())
    cur_ = size() -1;

  if(cur_ < 0)
    cur_ = 0;

  paint_page(vp,v);

  return false;
}


AddMapping page_up_func(CursorWindow::func_prior, &Impl::page_up, NonModifying);

bool
Impl::
page_up(viewport* vp, Viewer*v, input_event const *e)
{
  size_t page_offset = cur_ - page_top_;

  if(page_top_ == 0)
  {
    cur_ = 0;
  }
  else
  {
    page_top_ -= vp->size().row_ - first_row_;

    if(page_top_ < 0)
      page_top_ = 0;

    cur_ = page_top_ + page_offset;

    if(cur_ < 0)
      cur_ = size() -1;

    if(cur_ < 0)
      cur_ = 0;
  }

  paint_page(vp,v);

  return false;
}



AddMapping tab_right_func(CursorWindow::func_tab, &Impl::tab_right, NonModifying);

bool
Impl::
tab_right(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size() || cur_ < 0)
    return false;

  col_ += htab_;

  make_col_visible(vp,v);

  return false;

}



AddMapping char_right_func(CursorWindow::func_right, &Impl::char_right, NonModifying);

bool
Impl::
char_right(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size() || cur_ < 0)
    return false;

  ++col_;

  make_col_visible(vp,v);

  return false;

}

void
Impl::
make_col_visible(viewport* vp, Viewer* v)
{
  row_col size = vp->size();

  size_t  avail_cols = vwidth(size);

  if(col_ < page_left_)
  {
    // need to scroll left

     page_left_ = col_;
     page_left_ /= htab_;
     page_left_ *= htab_;

     paint_page(vp,v);
  }
  else
  if(col_ - page_left_ >= avail_cols)
  {
    // need to scroll right

    size_t target_col =  col_ / htab_;
           target_col += 1;
           target_col *= htab_;
        
    page_left_ = target_col - avail_cols;

    paint_page(vp,v);

  }
  else
  {
    restore_cursor(vp);
  }

}



AddMapping char_left_func(CursorWindow::func_left, &Impl::char_left, NonModifying);

bool
Impl::
char_left(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size() || cur_ < 0)
    return false;

  --col_;

  if( (int)(col_) < 0)
    col_ = 0;

  make_col_visible(vp,v);

  return false;

}



AddMapping line_down_func(CursorWindow::func_down, &Impl::line_down, NonModifying);

bool
Impl::
line_down(viewport* vp, Viewer*v, input_event const *e)
{
  ++cur_;

  make_line_visible(vp,v,false);

  return false;

}

void
Impl::
make_line_visible(viewport* vp, Viewer* v, bool center)
{
  if(cur_ >= size())
    cur_ = size() - 1;

  if(cur_ < 0)
    cur_ = 0;

  row_col size = vp->size();

  int avail_rows = vheight(size);

  int row_offset = cur_ - page_top_;

  if(row_offset < 0)
  {
    if(center)
      page_top_ = cur_ - avail_rows/2;
    else
      page_top_ = cur_;

    if(page_top_ < 0)
      page_top_ = 0;

    paint_page(vp,v);
  }
  else
  if(row_offset >= avail_rows)
  {
    if(center)
      page_top_ = cur_ - (avail_rows/2 - 1);
    else
      page_top_ = cur_ - (avail_rows - 1);

    if(page_top_ < 0)
      page_top_ = 0;

    paint_page(vp,v);

  }
  else
  {
    restore_cursor(vp);
  }


}




AddMapping line_up_func(CursorWindow::func_up, &Impl::line_up, NonModifying);

bool
Impl::
line_up(viewport* vp, Viewer*v, input_event const *e)
{
  --cur_;

  make_line_visible(vp,v,false);

  return false;

}



AddMapping line_home_func(CursorWindow::func_home, &Impl::line_home, NonModifying);

bool
Impl::
line_home(viewport* vp, Viewer*v, input_event const *e)
{
  col_ = 0;

  make_col_visible(vp,v);

  return false;

}



AddMapping line_end_func(CursorWindow::func_end, &Impl::line_end, NonModifying);

bool
Impl::
line_end(viewport* vp, Viewer*v, input_event const *e)
{

  col_ = 0;

  if(size() > cur_)
    col_ = std::string(line_text(cur_)).size();

  make_col_visible(vp,v);

  return false;

}



AddMapping file_top_func(CursorWindow::func_top, &Impl::file_top, NonModifying);

bool
Impl::
file_top(viewport* vp, Viewer*v, input_event const *e)
{

  cur_ = 0;

  make_line_visible(vp,v);

  return false;

}



AddMapping file_bottom_func(CursorWindow::func_bottom, &Impl::file_bottom, NonModifying);

bool
Impl::
file_bottom(viewport* vp, Viewer*v, input_event const *e)
{

  cur_ = size()-1;

  if(cur_ < 0)
    cur_ = 0;

  make_line_visible(vp,v);

  return false;

}




AddMapping line_mark_func(CursorWindow::func_mark, &Impl::line_mark, NonModifying);

bool
Impl::
line_mark(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= first_mark_ && cur_ < last_mark_ )
  {
    // clear extant mark
    first_mark_ = last_mark_ = -1;
  }
  else
  if(first_mark_ == last_mark_ )
  {
    // no previous mark:  mark this one line

    first_mark_ = cur_;
    last_mark_ = first_mark_ + 1;
  }
  else
  if(cur_ < first_mark_)
    first_mark_ = cur_;
  else
  if(cur_ >= last_mark_)
    last_mark_ = cur_ + 1;

  paint_page(vp,v);

  return false;
}



struct Accumulate_File_Lines
: public FileName::accumulate_lines
  //
  //
{

  rep_type &lines_;

  Accumulate_File_Lines(rep_type &lines)
  : lines_(lines)
  {
  }

  void push_back(std::string const &new_line)
  {
    lines_.push_back(new std::string(new_line));
  }

  std::string& back()
  {
    return *lines_.back().data();
  }

  void setBackHasCR(bool flag)
  {
     lines_.back().crRemoved_ = true; 
  }


};

void
Impl::
read_file()
{
  //
  //  Read the file into the lines_ data structure
  //

  Accumulate_File_Lines accum(lines_);

  if(! fullname_.exists() )
  {
    manager_->window()->beep();
    is_new_ = true;
  }
  else
  {

#ifdef _MSC_VER
    bool removeTrailingCROnUnix = false;
#else
    bool removeTrailingCROnUnix = true;
#endif

    
    std::string errors = fullname_.read_lines(accum,0,removeTrailingCROnUnix);
    
    if(errors.size() != 0)
    {
      CursorWindow::Message d("Error reading file " + fullname_);
    
      d += errors;
      d += "";
      d += "Press Enter to continue";
    
      d.popup(manager_->window());
    
      return;
    
    }

    is_writeable_ = fullname_.is_writeable();

  }

  std::string extension = fullname_.extension();
  std::string basename  = fullname_.basename();

  use_tabs_=true;


  if(extension == ".c"   ||
     extension == ".cc"  ||
     extension == ".h"   ||
     extension == ".cpp" ||
     extension == ".cxx" ||
     extension == ".C"   
    )
  {
    htab_     = 2;
    use_tabs_ = false;
  }
  else
  if(basename == "makefile" ||
     basename == "Makefile"
    )
  {
    htab_ = 8;
  }
  else
    htab_ = 4;


  // check for binary data

  if(lines_.size())
  {
      int count=0;
      bool hasBinary = false;


      for( ;   (!hasBinary)
            && (count < 10)
            && (count < lines_.size()); 
            ++count
         )
      {

          std::string const *p = lines_[count].data();

          if(!p)
            continue;
          

          std::string::const_iterator l=p->begin(),
                                      g=p->end();

          while(   !hasBinary 
                && (l != g)
               )
          {
            unsigned char c = *l++;

            if( c > '~')
            {
               hasBinary=true;
               break;
            }

            if(c < ' ')
            {
               if(    (c != '\r')
                  &&  (c != '\n')
                  &&  (c != 0x09)  // tab
                 )
               {
                   hasBinary = true;
                   break;
               }
            }

          }

      }  // processing characters in first 10 lines of the fil

      if(hasBinary)
      {
         manager_->window()->beep();

        CursorWindow::Message d("Warning:  Binary data");

        d += "";
        d += "";
        d += "Warning: this file contains binary data.";
        d += "";
        d += "This editor is not meant to be used with binary data.";
        d += "Saving changes is disabled to prevent data destruction.";
        d += "";
        d += "You can use ^Z to re-enable writing to the file, but do";
        d += "so at your own risk.";
        d += "";

        
        d.popup(manager_->window());
        is_writeable_ = false;

         
      }

  }  // check for binary



}

AddMapping word_next_func(CursorWindow::func_nextwd, &Impl::word_next, NonModifying);

bool
Impl::
word_next(viewport* vp, Viewer*v, input_event const *e)
{
  std::string line = line_text(cur_);

  std::string::iterator first = line.begin(),
                        last  = line.end();

  if(col_ >= line.size())
  {

    if(cur_ < size())
    {
      ++cur_;
      col_ = 0;
      make_line_visible(vp,v);
    }
  }
                        
  if(cur_ < size() && col_ < line.size())
  {
    // not off the end of the line

    std::string::iterator start = first + col_;

    std::string::iterator next_word_start = StrTool::find_next_word(start,
                                                                    last,
                                                                    word_chars_.begin(),
                                                                    word_chars_.end()
                                                                   );
   if(next_word_start != last)
   {
      col_  += next_word_start - start;

   }
   else
   {
      col_ = line.size();
   }

   make_col_visible(vp,v);
  }

  return false;
}


AddMapping word_prev_func(CursorWindow::func_prevwd, &Impl::word_prev, NonModifying);

bool
Impl::
word_prev(viewport* vp, Viewer*v, input_event const *e)
{
  std::string line = line_text(cur_);

  std::string::iterator first = line.begin(),
                        last  = line.end();

  if(col_)
  {
    std::string::iterator start = first + col_;

    std::string::iterator word_begin = StrTool::find_prev_word(start,
                                                               first,
                                                               last,
                                                               word_chars_.begin(),
                                                               word_chars_.end()
                                                              );
    col_ = word_begin - first;

    make_col_visible(vp,v);


  }
  else
  {
    if(cur_)
    {
      // move back to the end of the previous line

      --cur_;

      line = line_text(cur_);

      col_ = line.size();

      make_line_visible(vp,v);

    }
  }

  return false;
}


AddMapping word_del_func(CursorWindow::func_dw, &Impl::word_delete, Modifying);

bool
Impl::
word_delete(viewport* vp, Viewer*v, input_event const *e)
{
  std::string line = line_text(cur_);

  if(col_ >= line.size())
  {

    if(cur_ < size())
    {
      ++cur_;
      col_ = 0;
      line = line_text(cur_);
      make_line_visible(vp,v);
    }
  }

  std::string::iterator first = line.begin(),
                        last  = line.end();


                        
  if(cur_ < size() && col_ < line.size())
  {
    // not off the end of the line

    std::string::iterator start = first + col_;

    std::string::iterator next_word_start = StrTool::find_next_word(start,
                                                                    last,
                                                                    word_chars_.begin(),
                                                                    word_chars_.end()
                                                                   );
    size_t bytes_till_next_word;
                                                                
    if(next_word_start != last)
    {
       bytes_till_next_word = next_word_start - start;

    }
    else
    {
       bytes_till_next_word = line.size() - col_;;
    }


    last = first + ( col_ + bytes_till_next_word );

    line.erase(start,last);

    replace_line(cur_, line);

    row_col curpos = vp->curpos();

    make_col_visible(vp,v);

    vp->set_curpos(curpos.row_, left_);

    display_line(vp, cur_);

  }

  restore_cursor(vp);

  return false;
}


AddMapping char_insert_func(CursorWindow::func_data, &Impl::char_insert, Modifying);

bool
Impl::
char_insert(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
  {
    if(cur_ == 0)
    {
      lines_.push_back(new std::string(""));
      paint_page(vp,v);
      restore_cursor(vp);
    }
    else
      return false;  // something is wrong with the data structures
  }


  std::string line = line_text(cur_);

  std::string::iterator first = line.begin();

  if(col_ <= line.size())
  {
    line.insert(first+col_, e->value_);
  }
  else
  {
     line.append(col_ - line.size(), ' ');
     line += (char)(e->value_);
  }

  ++col_;

  replace_line(cur_, line);

  row_col curpos = vp->curpos();

  make_col_visible(vp,v);

  vp->set_curpos(curpos.row_, left_);

  display_line(vp, cur_);

  restore_cursor(vp);

  return false;
}


AddMapping char_delete_func(CursorWindow::func_dc, &Impl::char_delete, Modifying);

bool
Impl::
char_delete(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
    return false;


  std::string line = line_text(cur_);

  if(col_ >= line.size())
  {
    line_join(vp,v,e);

    line = line_text(cur_);

    col_ = line.size();

    make_col_visible(vp,v);

    return false;

  }


  std::string::iterator first = line.begin();

  if(col_ < line.size())
  {
    line.erase(first+col_);
  }

  replace_line(cur_,line);

  row_col curpos = vp->curpos();

  make_col_visible(vp,v);

  vp->set_curpos(curpos.row_, left_);

  display_line(vp, cur_);

  restore_cursor(vp);

  return false;
}


AddMapping line_del_func(CursorWindow::func_dl, &Impl::line_del, Modifying);

bool
Impl::
line_del(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
    return false;

  // erase the extant paste buffer

  Viewer::paste_buffer_type &paste_buffer = *v->paste_buffer();

  paste_buffer.erase(paste_buffer.begin(), paste_buffer.end());

  paste_buffer.insert(paste_buffer.begin(), *line_text(cur_).data() );

  v->commitPasteBuffer();

  erase_line( line_address(cur_), cur_ );

  if(cur_ >= size())
    cur_ = size() -1;

  if(cur_ < 0)
    cur_ = 0;

  if(first_mark_ != last_mark_)
  {
    //
    // handle adjustments to the marked region
    //
    if(cur_ >= first_mark_ && cur_ < last_mark_)
    {
      // delete a line in the marked region

      if(cur_ == first_mark_)
        ++first_mark_;
      else
        --last_mark_;
    }
    else
    if(cur_ < first_mark_)
    {
      --first_mark_;
      --last_mark_;
    }
  }

  paint_page(vp,v);

  return false;
}



AddMapping line_split_func(CursorWindow::func_enter, &Impl::line_split, Modifying);

bool
Impl::
line_split(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
  {
    // no lines defined yet

    lines_.push_back( new std::string("") );
    col_ = 0;
    paint_page(vp,v);
    return false;
  }

  std::string line = line_text(cur_);

  size_t first_non_blank_col=0;

  while(first_non_blank_col < line.size())
  {
    if(line[first_non_blank_col] != ' ')
      break;

    ++first_non_blank_col;
  }

  if(first_non_blank_col >= line.size())
    first_non_blank_col = 0;
  else
    left_margin_ = first_non_blank_col;

  if(col_ >= line.size())
  {
    // already past the end of line, just insert a new one

    rep_type::iterator cur_line_ptr = lines_.find(cur_);

    ++cur_line_ptr;

    lines_.insert(cur_line_ptr, new std::string(""));

    ++cur_;
    col_ = left_margin_;
    make_col_visible(vp,v);
    make_line_visible(vp,v);

    paint_page(vp,v);

    UndoOperation* op = push_undo_stack();

    op->code_    = UndoOperation::erase_line;
    op->lineno_  = cur_;


    return false;

  }

  // ok, add a new line which is the tail of the current line
  // and rip the tail off the current line


  rep_type::iterator cur_line_ptr = lines_.find(cur_);

  ++cur_line_ptr;

  std::string new_line = line;

  new_line.erase(new_line.begin(), new_line.begin() + col_);

  StrTool::remove_leading(new_line,' ');

  {
    UndoOperation *op = push_undo_stack();


    op->code_ = UndoOperation::join_lines;
    op->lineno_ = cur_;
    op->text_ = line;

  }


  std::string line_to_insert(left_margin_, ' ');
              line_to_insert += std::string(new_line);

  lines_.insert(cur_line_ptr, new std::string(line_to_insert) );

  line.erase(line.begin() + col_, line.end());

  replace_line(cur_,line,false);

  ++cur_;
  col_ = left_margin_;

  make_line_visible(vp,v);
  paint_page(vp,v);


  return false;
}


AddMapping line_clreol_func(CursorWindow::func_clreol, &Impl::line_clreol, Modifying);

bool
Impl::
line_clreol(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
    return false;

  std::string line = line_text(cur_);

  std::string::iterator first = line.begin();

  if(col_ < line.size())
  {
    line.erase(first+col_, line.end());
  }

  replace_line(cur_,line);

  row_col curpos = vp->curpos();

  make_col_visible(vp,v);

  vp->set_curpos(curpos.row_, left_);

  display_line(vp, cur_);

  restore_cursor(vp);

  return false;
}


AddMapping char_delprv_func(CursorWindow::func_dc_prev, &Impl::char_delprv, Modifying);

bool
Impl::
char_delprv(viewport* vp, Viewer*v, input_event const *e)
{
  if(cur_ >= size())
    return false;

  std::string line = line_text(cur_);

  if(col_ == 0)
  {
    // join this line to the previous line

    if(cur_)
    {
      // if not at top of the file

      std::string prevline = line_text(cur_-1);

      size_t prevlength = prevline.size();

      prevline += line;

      replace_line(cur_-1,prevline);

      erase_line(line_address(cur_), cur_);

      --cur_;

      col_ = prevlength;

      make_col_visible(vp,v);
      make_line_visible(vp,v);
      paint_page(vp,v);


    }

    return false;
  }
  else
  if(col_ > line.size())
  {
    // just move the cursor back one character

    --col_;
    make_col_visible(vp,v);
    restore_cursor(vp);
    return false;
  }

  // ok, delete the previous character and leave the cursor
  // in tht position

  --col_;
  make_col_visible(vp,v);

  return char_delete(vp,v,e);

}

AddMapping find_func(CursorWindow::func_find, &Impl::find_first, NonModifying);

bool
Impl::
find_first(viewport* vp, Viewer*v, input_event const *e)
{
  CursorWindow::Dialog dialog("Find string");

  char const *mix = "Y";

  if(mixed_case_ == false)
    mix = "N";

  dialog += new CursorWindow::Dialog::String("case",
                                             "Mixed case",
                                             mix,
                                             2
                                            );


  dialog += new CursorWindow::Dialog::String("mode",
                                             "(W)ord, (R)egexp, or (S)tring",
                                             (is_regex_ ? "R" : (match_words_ ? "W" : "S")),
                                             2
                                            );

  dialog += new CursorWindow::Dialog::String("text",
                                             "Search for",
                                             search_text_,
                                             40
                                            );

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

  dialog.set_first_input_field("text");


  if( dialog.popup(vp->window()) )
    return false;

  std::string mixed_case = dialog.element_value("case");

  if(   mixed_case.size() 
     && (mixed_case[0] == 'n' || mixed_case[0] == 'N')
    )
  {
    mixed_case_ = false;
  }
  else
  if(   mixed_case.size() 
     && (mixed_case[0] == 'y' || mixed_case[0] == 'Y')
    )
  {
    mixed_case_ = true;
  }


  std::string match_words = dialog.element_value("mode");

  match_words_ = false;
  is_regex_    = false;

  if(   match_words.size() 
     && (match_words[0] == 'r' || match_words[0] == 'R')
    )
  {
    is_regex_ =  true;
  }
  else
  if(   match_words.size() 
     && (match_words[0] == 'w' || mixed_case[0] == 'W')
    )
  {
    match_words_ = true;
  }

  std::string search_text = dialog.element_value("text");

  if(search_text.size() == 0)
    return false; // ignore searches for nothing

  search_text_ = search_text;

  int    saved_line   = cur_;
  size_t saved_col    = col_;

  --col_;  // first time through, let it try the current column
           // too.  find next always skips the current character

  if(is_regex_ && search_text_[0] == '^')
    --cur_;  // find next will increment it

  if(!find_next_helper(vp,v,e))
  {
    cur_ = saved_line;
    col_ = saved_col;
    vp->beep();
  }
  else
  {
    make_col_visible(vp,v);
    make_line_visible(vp,v);
  }

  return false;
}

AddMapping find_func_prev(CursorWindow::func_findprv, &Impl::find_prev, NonModifying);

bool
Impl::
find_prev(viewport* vp, Viewer*v, input_event const *e)
{
  int    saved_line   = cur_;
  size_t saved_col    = col_;

  if(!find_prev_helper(vp,v,e))
  {
    cur_ = saved_line;
    col_ = saved_col;
    vp->beep();
  }
  else
  {
    make_col_visible(vp,v);
    make_line_visible(vp,v);
  }

  return false;
}

bool
Impl::
find_prev_helper(viewport* vp, Viewer*v, input_event const *e)
{
  // the caller must save/restore cur_ and col_

  --col_;


  if(is_regex_)
  {
    SimpleRegex *p = &regexp_;

    p->SimpleRegex::~SimpleRegex();  // destruct current regex

    new(&regexp_) SimpleRegex(search_text_,  (mixed_case_ ? "i" : "") );

    //    regexp_ = search_text_;

    if(search_text_[0] == '^')
    {
      ++cur_;
      col_ = 0;
    }
  }
  
  


  bool force_col_to_end = false;

  while(cur_ >= 0)
  { // search all lines till beginning of file

    // get the text of the current line, tab expanded

    std::string curline = line_text(cur_);

    // make sure the line isn't empty and that the cursor
    // variable is properly positioned

    if(force_col_to_end)
    {
      col_ = curline.size()-1;

      if(col_ < 0)
      {
        --cur_;
        continue;
      }
    }

    // since backwards searches are hard, lets use a forward search
    // and make a list of all matches, as column numbers in this line,
    // then search around in that list for column numbers

    std::vector<int> matching_columns;

    for(int scan = 0; size_t(scan) < curline.size(); )
    {

      std::string::iterator where;


      if(is_regex_)
      {
        int startpos = scan;
        
        if(search_text_[0] == '^')
          startpos = 0;

        int count = regexp_(curline, startpos, curline.size());
        
        if(count > 0)
        {
          where = (curline.begin() + startpos + regexp_.matches()[0].offset);
        }
        else
          where = curline.end();
        
      }
      else
      {
        where = std::search(curline.begin() + scan,
                            curline.end(),
                            search_text_.begin(),
                            search_text_.end(),
                            CharCompare(this)
                           );
      }

                                        
      if(where != curline.end())
      {
        // found a match
        
        scan = where - curline.begin();
        
        matching_columns.push_back( scan );
        
        ++scan;
      }
      else
      {
        break;
      }
    }

    // matching_columns now has a list of all matches on this line


    if( int(col_) >= 0 )
    {
      // not past beginning of current line -- so try a search here

      // scan across the list of matches, until the current match
      // is farther to the right than the current column

      int match;

      for(match = 0; size_t(match) < matching_columns.size(); ++match)
      {
        if(matching_columns[match] > int(col_) )
          break;
      }

      --match;

      if(match >= 0)
      {
          std::string::iterator where = curline.begin() + matching_columns[match];
        
         if(match_words_)
         {
           // if matching only whole words, check to see if this is in fact a word
           // and if not, don't stop searching
        
           bool begin_starts_word = (where == curline.begin());
        
           if(!begin_starts_word)
             begin_starts_word = !is_word_char(where[-1]);
        
           std::string::iterator word_end = where + search_text_.size();
        
           bool end_ends_word = (word_end == curline.end());
        
           if(!end_ends_word)
             end_ends_word = !is_word_char(*word_end);
        
           if(begin_starts_word && end_ends_word)
           {
             col_ = where - curline.begin();
             return true;
           }
        
           col_ = where - curline.begin();
           --col_;
           force_col_to_end = false;
        
           continue;
        
        
         }
         else
         {
           // any old match will do, so quit
           col_ = where - curline.begin();
           return true;
         }
      }
    }

    --cur_;

    force_col_to_end=true;

  }


  return false;

}

AddMapping find_func_next(CursorWindow::func_findnxt, &Impl::find_next, NonModifying);

bool
Impl::
find_next(viewport* vp, Viewer*v, input_event const *e)
{
  int    saved_line   = cur_;
  size_t saved_col    = col_;

  if(!find_next_helper(vp,v,e))
  {
    cur_ = saved_line;
    col_ = saved_col;
    vp->beep();
  }
  else
  {
    make_col_visible(vp,v);
    make_line_visible(vp,v);
  }

  return false;
}



bool
Impl::
find_next_helper(viewport* vp, Viewer*v, input_event const *e)
{
  // the caller must save/restore cur_ and col_

  ++col_;  // note that replace_next() decrements this prior to the call to
           // replace_next_helper() which calls this function.

  if(is_regex_)
  {
    SimpleRegex *p = &regexp_;

    p->SimpleRegex::~SimpleRegex();  // destruct current regex

    new(&regexp_) SimpleRegex(search_text_,  (mixed_case_ ? "i" : "") );

    //    regexp_ = search_text_;

    if(search_text_[0] == '^')
    {
      ++cur_;
      col_ = 0;
    }
  }


  while(cur_ < lines_.size())
  { // search all lines till eof

    std::string curline = line_text(cur_);

    if(col_ < curline.size())
    {

      int startpos = col_;

      // not past end of current line -- so try a search here

      std::string::iterator where;


      if(is_regex_)
      {
        
        if(search_text_[0] == '^')
          startpos = 0;

        int count = regexp_(curline, startpos, curline.size());
        
        if(count > 0)
        {
          where = (curline.begin() + regexp_.matches()[0].offset);
        }
        else
          where = curline.end();
        
      }
      else
      {
        where = std::search(curline.begin() + col_,
                                                  curline.end(),
                                                  search_text_.begin(),
                                                  search_text_.end(),
                                                  CharCompare(this)
                                                 );
      }
                                        
      if(where != curline.end())
      {
        
         if(match_words_ && !is_regex_)
         {
           // if matching only whole words, check to see if this is in fact a word
           // and if not, don't stop searching
        
           bool begin_starts_word = (where == curline.begin());
        
           if(!begin_starts_word)
             begin_starts_word = !is_word_char(where[-1]);
        
           std::string::iterator word_end = where + search_text_.size();
        
           bool end_ends_word = (word_end == curline.end());
        
           if(!end_ends_word)
             end_ends_word = !is_word_char(*word_end);
        
           if(begin_starts_word && end_ends_word)
           {
             col_ = where - curline.begin();
             return true;
           }
        
           col_ = where - curline.begin();
           ++col_;
        
           continue;
        
        
         }
         else
         {
           // any old match will do, so quit
           col_ = where - curline.begin();



           return true;
         }
      }
    }

    ++cur_;
    col_ = 0;

  }


  return false;

}






AddMapping replace_first_func(CursorWindow::func_repl, &Impl::replace_first, Modifying);

bool
Impl::
replace_first(viewport* vp, Viewer*v, input_event const *e)
  // Prompt the user for a find/replacement pair and replace the first
  // match.
{
  CursorWindow::Dialog dialog("Replace string");


  char const *mix = "Y";

  if(mixed_case_ == false)
    mix = "N";

  dialog += new CursorWindow::Dialog::String("case",
                                             "Mixed case",
                                             mix,
                                             2
                                            );

  dialog += new CursorWindow::Dialog::String("mode",
                                             "(W)ord, (R)egexp, or (S)tring",
                                             (is_regex_ ? "R" : (match_words_ ? "W" : "S")),
                                             2
                                            );

  dialog += new CursorWindow::Dialog::String("all", "Replace (a)ll or (n)ext",
                                             "n",
                                             2
                                            );

  dialog += new CursorWindow::Dialog::String("find",
                                             "Search for",
                                             search_text_,
                                             40
                                            );
                                        
  dialog += new CursorWindow::Dialog::String("replacement",
                                             "Replace with",
                                             replacement_,
                                             40
                                            );
                                        

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

  dialog.set_first_input_field("find");

  if( dialog.popup(vp->window()) )
    return false;

  std::string mixed_case = dialog.element_value("case");

  if(   mixed_case.size() 
     && (mixed_case[0] == 'n' || mixed_case[0] == 'N')
    )
  {
    mixed_case_ = false;
  }
  else
  if(   mixed_case.size() 
     && (mixed_case[0] == 'y' || mixed_case[0] == 'Y')
    )
  {
    mixed_case_ = true;
  }

  std::string match_words = dialog.element_value("mode");

  match_words_ = false;
  is_regex_    = false;

  if(   match_words.size() 
     && (match_words[0] == 'r' || match_words[0] == 'R')
    )
  {
    is_regex_ =  true;
  }
  else
  if(   match_words.size() 
     && (match_words[0] == 'w' || mixed_case[0] == 'W')
    )
  {
    match_words_ = true;
  }


  std::string search_text = dialog.element_value("find");
  std::string replacement = dialog.element_value("replacement");

  if(search_text.size() == 0)
    return false;

  search_text_ = search_text;
  replacement_ = replacement;

  int    saved_line = cur_;
  size_t saved_col  = col_;


  if(is_regex_ && search_text_[0] == '^')
    --cur_;  // replace_next_helper, through find next helper, will increment it

  if( tolower(dialog.element_value("all")[0]) == 'a')
  {
    // replace all matches

    UndoOperation::undo_stack* nested_changes = new UndoOperation::undo_stack;

    undo_stack_.swap(*nested_changes);  // temporarily swap the real undo
                                        // stack withe the new one just
                                        // created so we can then place the
                                        // changes caused by replace_next_helper
                                        // to be accumulated into the new
                                        // stack -- which will then be placed on
                                        // the real undo stack

    bool found_one=false;

    for(;;)
    {
        --col_;  // will be incremented immediately by replace_next_helper()
                 // through it's call to find_next_helper()

        if(!replace_next_helper(vp,v,e))
           break;

      found_one = true;
    }

    undo_stack_.swap(*nested_changes);  // put the old undo stack back


    UndoOperation* op = push_undo_stack();

    op->code_ = UndoOperation::nested_undo_ops;

    op->nested_undo_stack_ = nested_changes;

    op->nested_first_mark_ = first_mark_;
    op->nested_last_mark_  = last_mark_;

    if(!found_one)
    {
      vp->beep();
      cur_ = saved_line;
      col_ = saved_col;
    }
    else
    {
      // cursor left at end of replacement
    
      make_col_visible(vp,v);
      make_line_visible(vp,v);
      paint_page(vp,v);

    }

  }
  else
  {
    // replace only the next match

  --col_;  // replace_next_helper will increment col_
           // immediately through it's call to find_next_helper

    if(replace_next_helper(vp,v,e))
    {
      // cursor left at end of replacement
    
      make_col_visible(vp,v);
      make_line_visible(vp,v);
      paint_page(vp,v);
    
    }
    else
    {
      cur_ = saved_line;
      col_ = saved_col;
      vp->beep();
    }
  }


  return false;
}

bool
Impl::
replace_next_helper(viewport* vp, Viewer*v, input_event const *e)
{

  // note:  replace_next() decrements col_ before calling this function
  //        and find_next_helper increments it before doing anything else

  if(!find_next_helper(vp,v,e))
  {
    return false;
  }

  if(is_regex_)
  {
    std::string curline = line_text(cur_);

    std::string replacement = regexp_.substitute(curline, replacement_);

    replace_line(cur_,replacement);

    col_ += regexp_.matches()[0].length;

    col_ += replacement.size() - curline.size();

  }
  else
  {

    // found it, cursor is at the beginning of the word

    std::string curline = line_text(cur_);

    std::string::iterator target = curline.begin() + col_;

    curline.erase(target, target + search_text_.size());

    curline.insert(col_, replacement_);

    replace_line(cur_,curline);

    col_ += replacement_.size();

  }

  return true;

}



AddMapping replace_next_func(CursorWindow::func_replnext, &Impl::replace_next, Modifying);

bool
Impl::
replace_next(viewport* vp, Viewer*v, input_event const *e)
{

  int    saved_line   = cur_;
  size_t saved_col    = col_;


  --col_;  // it will be incremented immediately find_next_helper which is called
           // the first thing in find_next_helper

  if(!replace_next_helper(vp,v,e))
  {
    cur_ = saved_line;
    col_ = saved_col;
    vp->beep();
  }
  else
  {

    make_col_visible(vp,v);
    make_line_visible(vp,v);

    vp->set_curpos(first_row_ + cur_ - page_top_, left_);
    display_line(vp, cur_);

    restore_cursor(vp);

  }

  return false;
}


AddMapping delete_block_func(CursorWindow::func_db, &Impl::block_delete, Modifying);

bool
Impl::
block_delete(viewport* vp, Viewer*v, input_event const *e)
  // cut the marked block to the paste buffer
{
  if(first_mark_ == last_mark_)
  {
    vp->beep();
    return false;  // no marked block
  }


  // erase the extant paste buffer, fill it with the deleted
  // items

  Viewer::paste_buffer_type &paste_buffer = *v->paste_buffer();

  paste_buffer.erase(paste_buffer.begin(), paste_buffer.end());

  // Create an undo operation to hold the deleted lines

  UndoOperation *op = push_undo_stack();

  op->code_   = UndoOperation::insert_block;
  op->lineno_ = first_mark_;

  // delete the lines and copy them to the paste
  // buffer

  while(last_mark_ != first_mark_)
  {
    // delete marked lines starting at tail to simplify work

    --last_mark_;

    rep_type::iterator scan = line_address(last_mark_);

    if(scan != lines_.end())
    {
      EditLine &el =*scan;

      paste_buffer.insert(paste_buffer.begin(), el);
      op->block_.push_back(el);

      erase_line(scan, last_mark_, false);  // erase but don't save undo info
                                            // since we are doing it already
    }

  }

  cur_ = first_mark_;
  col_ = 0;
  page_left_ = 0;
  page_top_  = first_mark_;

  first_mark_ = last_mark_ = -1;

  paint_page(vp, v);

  v->commitPasteBuffer();


  return false;
}

AddMapping paste_block_func(CursorWindow::func_paste, &Impl::block_paste, Modifying);

bool
Impl::
block_paste(viewport* vp, Viewer*v, input_event const *e)
  // cut the marked block to the paste buffer
{
  Viewer::paste_buffer_type &paste_buffer = *v->paste_buffer();

  Viewer::paste_buffer_type::iterator first = paste_buffer.begin(),
                                      last  = paste_buffer.end();


  UndoOperation* op = push_undo_stack();

  op->code_ = UndoOperation::delete_block;
  op->count_= 0;
  op->lineno_ = cur_;
                                
  while(first != last)
  {
    std::string const *insertedLine = &( *first++ );

    std::string buffer;

    if(use_tabs_)
    {
       // if we are going to save this file with tabs, then we should 
       // tab compress lines from the paste buffer by replacing groups of 8 
       // spaces with tabs.

       buffer = StrTool::pack_tabs(insertedLine->c_str());

       insertedLine = &buffer;

    }
    else
    {
       // if we are not saving with tabs, expand any tabs that might be in the line

       buffer = StrTool::expand_tabs(insertedLine->c_str());

       insertedLine = &buffer;

    }


    lines_.insert( lines_.find(cur_), new std::string(*insertedLine) );

    ++cur_;
    ++op->count_;
  }

  make_line_visible(vp, v);
  paint_page(vp,v);

  return false;
}



AddMapping file_insert_func(CursorWindow::func_insfile, &Impl::file_insert, Modifying);

bool
Impl::
file_insert(viewport* vp, Viewer*v, input_event const *e)
  // read a file into the current buffer above the current line
{

  FileName f(fullname_);

  CursorWindow::FileSelector d("Insert File",  f.dirname() + "*", "");

  std::string rv = d.popup(manager_->window(), v);

  if(rv.empty())
     return false;


  std::ifstream s(rv.c_str());

  if(!s.good())
  {
      CursorWindow::Message  d("Error");

      d += std::string("Can not open file ") + rv;

      d.popup(manager_->window());

      return false;
  }

  UndoOperation* op = push_undo_stack();

  op->code_ = UndoOperation::delete_block;
  op->count_= 0;
  op->lineno_ = cur_;
      

  std::string line;

  while(std::getline(s, line))
  {
    if(!use_tabs_)
       line = StrTool::expand_tabs(line);

    lines_.insert( lines_.find(cur_), new std::string(line) );

    ++cur_;
    ++op->count_;
  }

  make_line_visible(vp, v);
  paint_page(vp,v);

  return false;
}

AddMapping copy_block_func(CursorWindow::func_cb, &Impl::block_copy, NonModifying);

bool
Impl::
block_copy(viewport* vp, Viewer*v, input_event const *e)
  // copy the marked block to the paste buffer
{
  if(first_mark_ == last_mark_)
    return false;  // no marked block

  Viewer::paste_buffer_type &paste_buffer = *v->paste_buffer();

  paste_buffer.erase(paste_buffer.begin(), paste_buffer.end());

  // copy the lines and copy them to the paste
  // buffer

  while(last_mark_ != first_mark_)
  {
    // copy marked lines starting at tail to simplify work

    --last_mark_;

    rep_type::iterator scan = lines_.find(last_mark_);

    if(scan != lines_.end())
    {
      EditLine &el =*scan;

      paste_buffer.insert(paste_buffer.begin(), *el.data());

    }

  }

  v->commitPasteBuffer();  // write the paste buffer to the os

  first_mark_ = last_mark_ = -1;

  paint_page(vp, v);


  return false;
}

AddMapping save_block_func(CursorWindow::func_cb, &Impl::block_copy, NonModifying);

bool
Impl::
block_save(viewport* vp, Viewer*v, input_event const *e)
  // save the block to a file
{
  if(first_mark_ == last_mark_)
  {
    vp->beep();

    return false;  // no marked block
  }

  FileName f(fullname_);

  CursorWindow::FileSelector d("Save Block to File",  f.dirname() + "*", "");

  std::string target = d.popup(manager_->window(), v);

  if(target.empty())
     return false;

  std::ofstream  targetFile(target.c_str());

  if(!targetFile.good())
  {
     manager_->window()->beep();
     return false;
  }

  for(int i = first_mark_; i < last_mark_; ++i)
  {
    rep_type::iterator scan = lines_.find(i);

    if(scan != lines_.end())
    {
      EditLine &el =*scan;

      std::string data = StrTool::expand_tabs(*el.data());

      targetFile << data << '\n';

    }

  }


  paint_page(vp, v);


  return false;
}


AddMapping transform_block_func(10000, &Impl::block_transform, Modifying);

bool
Impl::
block_transform(viewport* vp, Viewer*v, input_event const *e)
  // cut the marked block to the paste buffer
{
  
  
  if(first_mark_ == last_mark_)
  {
    vp->beep();
    return false;  // no marked block
  }


  static std::list<std::string>  script;  // maintained across multiple invocations

  if(script.size() == 0)
  {
      script.push_back("");
      script.push_back("p");
      script.push_back("");   // always guarantee an empty line at the end
  }
  else
  {
     // make sure that there's always a blank line to add one more command if needed.


     if(!script.back().empty())
     {
        script.push_back("");
     }
  }

  bool promptUser=true;
  
  {
      typedef std::pair<Viewer*, FileName> ViewerInfo;


      std::list<ViewerInfo> viewers;

      manager_->findMatchingViewers(FileName("*.mused"), viewers);

      if(!viewers.empty())
      {

         script.clear();


         Viewer* activeViewer = viewers.front().first;

         if(viewers.size() > 1)
         {

             CursorWindow::Selection d("Choose a mused script:");
         
             CXXTLS_FOREACH(ViewerInfo &cur, viewers)
             {
                d += cur.second;
             }


             if(d.popup(manager_->window()))
               return false;
         
             CXXTLS_FOREACH(ViewerInfo &cur, viewers)
             {
                 if(cur.second == d.selection_)
                 {
                    activeViewer = cur.first;
                    break;
                 }
             }
             
         }


         if(!activeViewer->fetchAllLines(script))
         {
            
             CursorWindow::Message d("Error:  cannot access script");
             
             d += "Press Enter to continue";
             
             d.popup(manager_->window());
             
             return false;
         }
         else
         {
            promptUser = false;
         }
      }

  }


  
  if(promptUser)
  {
      // create a multi-line string dialog that lets the user
      // enter a script.
    
      CursorWindow::Dialog d("Enter a short MUSED script");
    
      int count=0;
    
      CXXTLS_FOREACH(std::string const &cur, script)
      {
          char name  [40];
          char label [40];
    
          ++count;
    
          snprintf(name,  sizeof(name),  "cmd%d", count);
          snprintf(label, sizeof(label), "%d", count);
    
    
          d += new CursorWindow::Dialog::String(name,
                                                label,
                                                cur,
                                                50
                                                );
      }
      
      // let the user edit the dialog text
    
      if(d.popup( manager_->window() ))
      {
        return false;
      }
    
      // fetch the text out of the dialog
    
      count=0;
      CXXTLS_FOREACH(std::string &cur, script)
      {
          char name  [40];
          ++count;
    
          snprintf(name,  sizeof(name),  "cmd%d", count);
    
          cur = d.element_value(name);
    
      }
  }

  int saved_first_mark = first_mark_;
  int saved_last_mark  = last_mark_;

  UndoOperation::undo_stack* nested_changes = new UndoOperation::undo_stack;
  
  undo_stack_.swap(*nested_changes);  // temporarily swap the real undo
                                      // stack withe the new one just
                                      // created so we can then place the
                                      // changes caused by replace_next_helper
                                      // to be accumulated into the new
                                      // stack -- which will then be placed on
                                      // the real undo stack

  std::list<std::string>  inputBlock;



  // Create an undo operation to hold the deleted lines
  {
      UndoOperation *op = push_undo_stack();
    
      op->code_   = UndoOperation::insert_block;
      op->lineno_ = first_mark_;
    
      // delete the lines and copy them to the paste
      // buffer
    
      while(last_mark_ != first_mark_)
      {
        // delete marked lines starting at tail to simplify work
    
        --last_mark_;
    
        rep_type::iterator scan = line_address(last_mark_);
    
        if(scan != lines_.end())
        {
          EditLine &el =*scan;

          std::string tmp = el;

          inputBlock.push_front(tmp);   // records are processed in reverse order
                                        // because of the way undo works, 
                                        // but we need them in forward order
                                        // for the muSED::apply operation.
    
          op->block_.push_back(tmp);
    
          erase_line(scan, last_mark_, false);  // erase but don't save undo info
                                                // since we are doing it already
        }
    
      }
  }


  std::list<std::string> output;

  std::string error = muSED::apply(script, inputBlock, output);

  {
    UndoOperation* op = push_undo_stack();
    
    op->code_ = UndoOperation::delete_block;
    op->count_= 0;
    op->lineno_ = first_mark_;

    cur_ = first_mark_;
    
    std::list<std::string>::iterator first = output.begin(),
                                     last  = output.end();

    while(first != last)
    {


      std::string insertedLine = *first++;
    
      std::string buffer;
    
      if(use_tabs_)
      {
         // if we are going to save this file with tabs, then we should 
         // tab compress lines from the paste buffer by replacing groups of 8 
         // spaces with tabs.
    
         buffer = StrTool::pack_tabs(insertedLine.c_str());
    
         insertedLine = buffer;
    
      }
      else
      {
         // if we are not saving with tabs, expand any tabs that might be in the line
    
         buffer = StrTool::expand_tabs(insertedLine.c_str());
    
         insertedLine = buffer;
    
      }
    
      lines_.insert( lines_.find(cur_), new std::string(insertedLine) );
    
      ++cur_;
      ++op->count_;
    
    }
  }

  last_mark_ = cur_;

  cur_ = first_mark_;

  {
    undo_stack_.swap(*nested_changes);  // put the old undo stack back


    UndoOperation* op = push_undo_stack();

    op->code_ = UndoOperation::nested_undo_ops;

    op->nested_undo_stack_ = nested_changes;

    op->nested_first_mark_ = saved_first_mark;
    op->nested_last_mark_  = saved_last_mark;
  }


  if(!error.empty())
  {
      CursorWindow::Message d("Script Error");

      d += error;

      d.popup(manager_->window());

  }

  paint_page(vp, v);


  return false;
}



void
Impl::
save(viewport* vp, TextEditor*v, input_event const *e)
{
  if(!is_writeable_)
  {
    std::string write_anyway("Change to write mode?");

    CursorWindow::Selection d("File not opened for write");

    d += "Abandon attempt to save?";
    d += write_anyway;

    if(d.popup(manager_->window()))
      return;

    if(d.selection_ == write_anyway)
    {
      is_writeable_ = true;
    }
    else
    {
      return;
    }
  }


  FILE *f = fopen(fullname_.c_str(), "wb");

  row_col window_size = vp->window()->size();

  is_dirty_ = false;

  if(!f)
  {
    vp->beep();

    CursorWindow::Message m( std::string("Error opening ") +
                             fullname_.shorten(window_size.col_ - 27) +
                             " for write"
                           );
                        
    char buffer[40];

    sprintf(buffer, "errno is %s", strerror(errno));

    m += buffer;
    m += "Press enter to continue";

    m.popup(vp->window());

    is_writeable_ = false;

    return;

  }

  bool force_unix_eol=false;

  #ifdef _MSC_VER
    if( 
        getenv("HOME") && 
        (getenv("SFUDIR") || getenv("CYGWIN") )
      )
      force_unix_eol = true;
  #endif

  rep_type::iterator first = lines_.begin(),
                     last  = lines_.end();

  while(first != last)
  {
    std::string data;

    bool addCR = (*first).crRemoved_;

    
    if(use_tabs_)
      data = (*first++).maybe_tabbify();
    else
      data = *(*first++).data();

    fwrite(data.data(), data.size(), 1, f);
    
    if(force_unix_eol)
    {
      char eol='\n';
      fwrite(&eol, 1, 1, f);
    }
    else
    {
      if(addCR)
      {
         // on unix and linux, this flag might be set but on
         // dos it won't ever be.

         fwrite("\r\n", 2, 1, f); // add full dos eol sequence

       
      }
      else
           fwrite(&EOL_Sequence, sizeof(EOL_Sequence), 1, f);
    }

  }


  fclose(f);
}

AddMapping line_goto_func(CursorWindow::func_goto, &Impl::line_goto, NonModifying);

bool
Impl::
line_goto(viewport* vp, Viewer*v, input_event const *e)
  // prompt the user and goto a specified line
{

  StreamableString ss;

  ss << "Goto a line between 1 and " << lines_.size();


  CursorWindow::Dialog dialog(ss);

  StreamableString lineno;

  lineno << (1+cur_);

  dialog += new CursorWindow::Dialog::String("line",
                                             "Goto line",
                                             lineno,
                                             12
                                            );
                                        

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

  if( dialog.popup(vp->window()) )
    return false;

  int target_line=1;

  sscanf(dialog.element_value("line").c_str(), "%d", &target_line);

  --target_line;


  if(target_line < 0 || target_line >= lines_.size())
    return false;

  cur_ = target_line;

  make_line_visible(vp,v);

  restore_cursor(vp);

  return false;
}


AddMapping line_undo(CursorWindow::func_undo, &Impl::undo, Modifying);

bool
Impl::
undo(viewport* vp, Viewer*v, input_event const *e)
  // pop the undo stack and perform the reverse operation of that
  // action
{
  bool painting=true;  // update screen after changes

  if(!e)
    painting = false; // nested undo's don't paint, only when finished


  if(undo_stack_.begin() != undo_stack_.end())
  {
    // there is something to undo

    std::auto_ptr<UndoOperation> op(undo_stack_.front());

    undo_stack_.pop_front();

    is_dirty_ = true;

    switch(op->code_)
    {
      case  UndoOperation::replace_line:
          replace_line(op->lineno_, op->text_, false);
          cur_ = op->lineno_;
          if(painting)
          {
            make_line_visible(vp,v);
            paint_page(vp,v);
          }
        break;

      case  UndoOperation::insert_line:
          lines_.insert( lines_.find(op->lineno_), new std::string(op->text_));
          cur_ = op->lineno_;
          if(painting)
          {
            make_line_visible(vp,v);
            paint_page(vp,v);
          }
        break;
      case  UndoOperation::erase_line:
          lines_.erase( lines_.find(op->lineno_) );
          cur_ = op->lineno_;
          if(painting)
          {
            make_line_visible(vp,v);
            paint_page(vp,v);
          }
        break;
        
      case  UndoOperation::break_lines:
          lines_.erase( lines_.find(op->lineno_) );
          cur_ = op->lineno_;
          {
            std::list<std::string>::iterator first = op->block_.begin(),
                                             last  = op->block_.end();
                                        
            while(last != first)
            {
              --last;
              std::string &r = *last;
        
              lines_.insert(lines_.find(cur_), new std::string(r));
            }
          }
        
          if(painting)
          {
            make_line_visible(vp,v);
            paint_page(vp,v);
          }
        break;
        

      case  UndoOperation::join_lines:

          if(op->lineno_ < lines_.size()-1)
          {
            std::string current_line_text = line_text(op->lineno_);
        
            col_ = current_line_text.size();
        
            cur_ = op->lineno_;
        
            lines_.erase( lines_.find(cur_+1) );
        
            replace_line(cur_, op->text_, false);
        
            if(painting)
            {
              make_line_visible(vp,v);
              paint_page(vp,v);
            }
          }
        break;
        
      case  UndoOperation::insert_block:
        {
          std::list<std::string>::iterator first = op->block_.begin(),
                                           last  = op->block_.end();
                                        
          while(first != last)
          {
            lines_.insert(lines_.find(op->lineno_), new std::string(*first));
            ++first;
          }

          if(painting)
            paint_page(vp,v);
        
        }
        break;
        
      case  UndoOperation::replace_block:
        {
          std::list<std::string>::iterator first = op->block_.begin(),
                                           last  = op->block_.end();
                                        
          while(first != last)
          {
            replace_line(op->lineno_++, std::string(*first), false);
        
            ++first;
          }

          if(painting)
            paint_page(vp,v);
        
        }
        break;
        
        
      case  UndoOperation::delete_block:
        {
          // this algorithm is necessary because lines_ is a
          // vector and whenever you insert or delete into a vector
          // _all_ iterators are invalid
        
        
          while(op->count_)
          {
            rep_type::iterator first = lines_.find(op->lineno_);
        
            lines_.erase(first);
        
             --op->count_;
          }
                
          cur_ = op->lineno_;
        
          if(painting)
          {
            make_line_visible(vp,v);
            paint_page(vp,v);
          }
        
        }
        break;
        
      case UndoOperation::nested_undo_ops:
        {
           UndoOperation::undo_stack* nested_changes = op->nested_undo_stack_;
        
           undo_stack_.swap(*nested_changes);
        
           bool something_to_do = !undo_stack_.empty();
        
           while(!undo_stack_.empty())
           {
             undo(vp,v,0);  // the 0 for e is flag saying don't paint
           }
        
           if(something_to_do)
             is_dirty_ = true;
        
           undo_stack_.swap(*nested_changes);
        
           delete nested_changes;

           first_mark_ = op->nested_first_mark_;
           last_mark_  = op->nested_last_mark_;
        
           if(painting)
           {
             make_line_visible(vp,v);
             paint_page(vp,v);
           }
        
        }
        break;
    }

  }
  else
  {
    vp->beep();
    is_dirty_ = false;
  }

  return false;
}

bool
Impl::
show_symbols(viewport* vp, Viewer*v, input_event const *e)
{


  std::string name = fullname_ + ".cpptagdb";

  Viewer* oldie = manager_->find_viewer(name);

  if(oldie)
  {
    manager_->activate(oldie);
  }
  else
  {

    manager_->window()->close();

    Viewer *newbie = manager_->open(name);  // name is the "current" file name plus .cpptagdb.  The
                                            // symbol viewer knows to use cpptagdb.exe to get the
                                            // correct output instead of actually reading files whose
                                            // name ends in .cpptagdb

    manager_->window()->open();

    if(!newbie)
      manager_->window()->beep();
    else
    {
      manager_->hsplit(newbie, name);
    }

  }


  return false;
}





struct Is_Path_Separator
{
  bool operator() (char c) const
  {
    return c == FileName::PATH_separator ;
  }

};

bool
Impl::
snatch_edit(viewport* vp, Viewer*v, input_event const *e)
  //
  // Snatch the text under the cursor and assume it is a filename and bring up
  // an edit session on that file.  Also, if the text under the cursor looks
  // like a recognized compiler error message or grep output, make sure the
  // current line is positioned correctly in the edited file.
  //
{

  std::string s = line_text(cur_);

  size_t rLength = s.size();

  if( col_ >= rLength || s[col_] == ' ')
  { // not sitting on a word

    manager_->window()->beep();

    return false;

  } // not sitting on a word

  std::string tmp( s.begin() + col_, s.end());

  FileName name;
  int      number=0;

  if(!StrTool::snatch_file_info(tmp, name, number))
  {
    manager_->window()->beep();

    return false;

  }

  name = manager_->find_file_in_standard_locations(name, fullname_.dirname());

  if(name.empty())
  {
    manager_->window()->beep();

    return false;

  }

  Viewer* oldie = manager_->find_viewer(name);

  if(oldie)
  {
    oldie->set_row_col_hint(number-1,0);
    manager_->activate(oldie);
  }
  else
  {
    if(!name.exists())
    {
       CursorWindow::Message m(name + " does not exist");

       m += "Sorry, can't find it";
       m += "";
       m += "Press Enter to continue";

       m.popup(manager_->window());

       return false;
    }

    Viewer *newbie = manager_->edit(name);

    if(!newbie)
      manager_->window()->beep();
    else
    {
      newbie->set_row_col_hint(number-1, 0);  // 0 based line numbers!
      manager_->vsplit(newbie, name);
    }

  }


  return false;
}

void
TextEditor::
set_row_col_hint(size_t line_setting, size_t col, bool force_repaint)
{

  int line = line_setting;

  if(line >= 0 && line < impl_->size())
  {
    impl_->cur_ = line;
    impl_->page_top_ = line;
    impl_->col_ = col;
    impl_->page_left_ = col;
  }

}

void
TextEditor::
set_read_only()
{
  impl_->is_writeable_ = false;
}




bool
Impl::
word_sfind(viewport* vp, Viewer*v, input_event const *e)
{
  std::string curline = line_text(cur_);

  if(col_ >= curline.size() || curline[col_] == ' ')
  {
    vp->beep();
    return false;
  }

  std::string::const_iterator first = curline.begin() + col_,
                              last  = curline.end();
                        
  search_text_ = "";

  while(first != last && is_word_char(*first) )
  {
    search_text_ += *first++;
  }

  if(search_text_.size() == 0)
  {
    vp->beep();
    return false;
  }

  size_t col_save = col_;
  int    cur_save = cur_;

  if(find_next_helper(vp, v, e))
  {
    make_line_visible(vp,v);
    make_col_visible(vp,v);
  }
  else
  {
    vp->beep();
    col_ = col_save;
    cur_ = cur_save;
  }

  return false;
}

bool
Impl::
etags_first(viewport* vp, Viewer*v, input_event const *e)
{
  EtagsDB* etags=(manager_->default_etags_db());  // pts to static object


  if(!etags || !etags->ok())
  {
    // error message will have been handled by ViewerManager code
    return false;
  }

  std::string symbol;
  std::string file;
  int         line;
  std::string matching_text;

  std::string curline = line_text(cur_);

  if( !(col_ >= curline.size() || curline[col_] == ' ') )
  {
    std::string::const_iterator first = curline.begin() + col_,
                                last  = curline.end();
                        
    while(first != last && is_word_char(*first) )
    {
      symbol += *first++;
    }
  }


  CursorWindow::Dialog d("Search TAGS (etags file) For A Symbol");

  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol Name",
                                        symbol,
                                        40
                                        );
                                
  if(d.popup(manager_->window()))
    return 0;

  symbol = d.element_value("symbol");

  if(symbol.size() == 0)
  {
    vp->beep();
    return false;
  }

  bool rv = etags->find_first(symbol, &file, &line, &matching_text);

  if(rv)
  {
    Viewer* oldie = manager_->find_viewer(file);

    if(oldie)
    {
      oldie->set_row_col_hint(line-1,0);
      manager_->activate(oldie);
    }
    else
    {

      Viewer* newbie = manager_->edit(file);

      if(newbie)
      {
        newbie->set_row_col_hint(line-1,0);

        manager_->vsplit(newbie, file);

      }
      else
        vp->beep();
    }

  }

  return false;
}

bool
Impl::
cpptags_first(viewport* vp, Viewer*v, input_event const *e)
{
  CppTagDB::Info* cpptags=(manager_->default_cpptags_db());  // pts to static object


  if(!cpptags)
  {
    // error message will have been handled by ViewerManager code
    return false;
  }

  std::string symbol;
  std::string file;
  int         line;
  std::string matching_text;

  std::string curline = line_text(cur_);

  if( !(col_ >= curline.size() || curline[col_] == ' ') )
  {
    std::string::const_iterator first = curline.begin() + col_,
                                last  = curline.end();
                        
    while(first != last && is_word_char(*first) )
    {
      symbol += *first++;
    }
  }


  CursorWindow::Dialog d("Search TAGPP.tagpp (cpptagdb.exe file) For A Symbol");

  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol Name",
                                        symbol,
                                        40
                                        );
                                
  if(d.popup(manager_->window()))
    return 0;

  symbol = d.element_value("symbol");

  if(symbol.size() == 0)
  {
    vp->beep();
    return false;
  }

  std::vector<cxxtls::CppTagDB::SymbolInfo const *> matches;

  cpptags->findMatchingMembers(symbol, matches);

  if(!matches.empty())
  {
    std::vector<ViewerManager::FileLocation>  locations;

    CXXTLS_FOREACH(CppTagDB::SymbolInfo const *cur, matches)
    {
       locations.push_back( ViewerManager::FileLocation(cur->file_, cur->line_) );
    }

    manager_->setFileLocations(locations);

    ViewerManager::FileLocation tmp;

    manager_->popFileLocation(tmp);

    file = tmp.filename_;
    line = tmp.lineNumber_;


    Viewer* oldie = manager_->find_viewer(file);

    if(oldie)
    {
      oldie->set_row_col_hint(line-1,0);
      manager_->activate(oldie);
    }
    else
    {

      Viewer* newbie = manager_->edit(file);

      if(newbie)
      {
        newbie->set_row_col_hint(line-1,0);

        manager_->vsplit(newbie, file);

      }
      else
        vp->beep();
    }

  }
  else
     vp->beep();

  return false;
}


bool
Impl::
etags_all(viewport* vp, Viewer*v, input_event const *e)
{
  EtagsDB* etags=(manager_->default_etags_db()); // pts to static object

  if(!etags || !etags->ok())
  {
    // error message will have been handled by ViewerManager code
    return false;
  }

  std::string symbol;
  std::string file;
  int         line;
  std::string matching_text;

  std::string curline = line_text(cur_);

  if( !(col_ >= curline.size() || curline[col_] == ' ') )
  {
    std::string::const_iterator first = curline.begin() + col_,
                                last  = curline.end();
                        
    while(first != last && is_word_char(*first) )
    {
      symbol += *first++;
    }
  }


  CursorWindow::Dialog d("Search TAGS (etags file) For All Matching Symbols");

  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol Name",
                                        symbol,
                                        40
                                        );
                                
  if(d.popup(manager_->window()))
    return 0;

  symbol = d.element_value("symbol");

  if(symbol.size() == 0)
  {
    vp->beep();
    return false;
  }

  bool rv = etags->find_first(symbol, &file, &line, &matching_text);

  if(rv)
  {
      CursorWindow::Selection d("Symbols matching " + symbol);
    
      d += "";

      while(rv)
      {
         std::string tmp = file;

         char buffer[40];

         snprintf(buffer, 40, ":%d", line);

         tmp += buffer;
         tmp += ' ';
         tmp += matching_text;

         d += tmp;

         rv = etags->find_next(&file, &line, &matching_text);

      }

      d += "";

      d += "Press Enter to continue";

      if(!d.popup(manager_->window()))
      {
          // user didn't abort

          std::string const &selection = d.selection_;

          size_t colon = selection.find_first_of(':');

          if(colon >= selection.size())
          {
            vp->beep();  // should never get here
          }
          else
          {
            // there is a filename:lineNumber pair

            file = selection.substr(0, colon);

            std::string tmp = selection.substr(colon+1, selection.size() - colon -1);

            line = 0;

            sscanf(tmp.c_str(), "%d", &line);

            Viewer* oldie = manager_->find_viewer(file);
        
            if(oldie)
            {
              oldie->set_row_col_hint(line-1,0);
              manager_->activate(oldie);
            }
            else
            {
        
              Viewer* newbie = manager_->edit(file);
        
              if(newbie)
              {
                newbie->set_row_col_hint(line-1,0);
        
                manager_->vsplit(newbie, file);
        
              }
              else
                vp->beep();
            }

          }
          

      }

  }
  else
    vp->beep();

  return false;
}

bool
Impl::
cpptags_all(viewport* vp, Viewer*v, input_event const *e)
{

  CppTagDB::Info* cpptags=(manager_->default_cpptags_db());  // pts to static object

  if(!cpptags)
  {
    // error message will have been handled by ViewerManager code
    return false;
  }

  std::string symbol;
  std::string file;
  int         line;
  std::string matching_text;


  std::string curline = line_text(cur_);

  if( !(col_ >= curline.size() || curline[col_] == ' ') )
  {
    std::string::const_iterator first = curline.begin() + col_,
                                last  = curline.end();
                        
    while(first != last && is_word_char(*first) )
    {
      symbol += *first++;
    }
  }


  CursorWindow::Dialog d("Search TAGPP.tagpp (cpptagdb.exe file) For All Matching Symbols");

  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol Name",
                                        symbol,
                                        40
                                        );
                                
  if(d.popup(manager_->window()))
    return 0;

  symbol = d.element_value("symbol");

  if(symbol.size() == 0)
  {
    vp->beep();
    return false;
  }

  std::vector<cxxtls::CppTagDB::SymbolInfo const *> matches;

 cpptags->findMatchingMembers(symbol, matches, false);  // insensitive comparison

  if(!matches.empty())
  {
      CursorWindow::Selection d("Symbols matching " + symbol);
    
      d += "";

      std::vector<cxxtls::CppTagDB::SymbolInfo const *>::const_iterator first, last;

      for(first = matches.begin(), last = matches.end(); first != last; ++first)
      {
         std::string tmp = (*first)->file_;

         char buffer[40];

         snprintf(buffer, 40, ":%d", (*first)->line_);

         tmp += buffer;

         d += tmp;

      }

      d += "";

      d += "Press Enter to continue";

      if(!d.popup(manager_->window()))
      {
          // user didn't abort

          std::string const &selection = d.selection_;

          size_t colon = selection.find_first_of(':');

          if(colon >= selection.size())
          {
            vp->beep();  // should never get here
          }
          else
          {
            // there is a filename:lineNumber pair

            file = selection.substr(0, colon);

            std::string tmp = selection.substr(colon+1, selection.size() - colon -1);

            line = 0;

            sscanf(tmp.c_str(), "%d", &line);

            Viewer* oldie = manager_->find_viewer(file);
        
            if(oldie)
            {
              oldie->set_row_col_hint(line-1,0);
              manager_->activate(oldie);
            }
            else
            {
        
              Viewer* newbie = manager_->edit(file);
        
              if(newbie)
              {
                newbie->set_row_col_hint(line-1,0);
        
                manager_->vsplit(newbie, file);
        
              }
              else
                vp->beep();
            }

          }
          

      }

  }
  else
    vp->beep();

  return false;
}



bool
Impl::
tags_next(viewport* vp, Viewer*v, input_event const *e)
{

  std::string file;
  int         line;
  std::string matching_text;

  ViewerManager::FileLocation loc;


  if(manager_->popFileLocation(loc))
  {
     // there is a saved file location


     file = loc.filename_;
     line = loc.lineNumber_;

  }
  else
  {
      EtagsDB *etags=(manager_->default_etags_db());  // pts to static object

      if(etags && etags->ok())
      {
        if(etags->find_next(&file, &line, &matching_text))
        {
           // found file and line
        }
        else
        {
           // no file location and unfortunately the etags
           // database does not contain the requested data.
      
      
           vp->beep();
           return false;
        }
      }
      else
      {
        // neither etags nor saved file locations could be accessed
      
        vp->beep();
      
      
        return false;
      }
  }

  Viewer* oldie = manager_->find_viewer(file);
  
  if(oldie)
  {
    oldie->set_row_col_hint(line-1,0);
    manager_->activate(oldie);
  }
  else
  {
  
    Viewer* newbie = manager_->edit(file);
  
    if(newbie)
    {
      newbie->set_row_col_hint(line-1,0);
  
      manager_->add(newbie, file);
  
    }
    else
      vp->beep();
  }


  return false;
}

AddMapping matching_char(CursorWindow::func_matching, &Impl::char_matching, NonModifying);



TextIterator
Impl::
top_pointer()
{
  return TextIterator(lines_, 0, 0);
}


TextIterator
Impl::
bot_pointer()
{
  return TextIterator(lines_, lines_.size(), 0);
}

TextIterator
Impl::
cur_pointer()
{
  std::string curline = line_text(cur_);

  if(cur_ >= lines_.size())
    return TextIterator(lines_, lines_.size(), 0);
  else
  if(col_ >= curline.size())
    return TextIterator(lines_, cur_, curline.size());

  return TextIterator(lines_, cur_, col_);
}

bool
Impl::
char_matching(viewport* vp, Viewer*v, input_event const *e)
{
  // find the character matching the one under the cursor

  TextIterator top = top_pointer(),  // get iterator to top of the edit session
               cur = cur_pointer(),  // get iterator to current file position
               bot = bot_pointer();  // get iterator to the bottom of the file

  if(cur == bot)
  {
    //
    // at end of file...
    //
    vp->beep();
    return false;
  }


  char match = *cur;
  bool down;
  char orig  = match;

  switch(match)
  {
    case '{':  match = '}'; down=true; break;
    case '(':  match = ')'; down=true; break;
    case '<':  match = '>'; down=true; break;
    case '[':  match = ']'; down=true; break;

    case '}':  match = '{'; down=false; break;
    case ')':  match = '('; down=false; break;
    case '>':  match = '<'; down=false; break;
    case ']':  match = '['; down=false; break;

    default:

      vp->beep();
      return false;
  }

  if(down)
  {
    // parse C++ tokens forward through the file until the match is found

    int depth = 0;

    while(cur != bot)
    {
      char c = *cur;

      if(c == orig)
        ++depth;
      else
      if(c == match)
      {
        --depth;
        if(depth == 0)
          break;
      }
      else
      if(c == '\'')
      {
        ++cur;
        
        while(cur != bot && *cur != '\'')
        {
          // skip quoted strings
        
          if(*cur == '\\') // skip any escape sequence
            ++cur;
        
          if(cur != bot)  // skip the current char
            ++cur;
        }
        
      }
      else
      if(c == '"')
      {
        ++cur;
        
        while(cur != bot && *cur != '"')
        {
          // skip quoted strings
        
          if(*cur == '\\') // skip any escape sequence
            ++cur;
        
          if(cur != bot)  // skip the current char
            ++cur;
        }
        
      }
      else
      if(c == '/')
      {
        // handle c++ style comments

        ++cur;

        if( (cur != bot) && (*cur == '/') )
        {
          while(  (cur != bot) && (*cur  != '\n') )
            ++cur;
        }


      }
      
      if(cur != bot)
        ++cur;
    }

  }
  else
  {
    // parse C++ tokens backwards through the file until the match is found

    int depth = 0;

    while(cur != top)
    {
      char c = *cur;

      if(c == orig)
        ++depth;
      if(c == match)
      {
        --depth;
        if(depth == 0)
          break;
      }
      else
      if(c == '\'' )
      { 

        // skip the trailing single quoted string
        // scan backwards from the last valid char in the string to the first
        // ' in the string -- taking into account this kind of annoyance:  '\''
        //                                                                   ^
        
        --cur;

        while(cur != top)
        {
           if(*cur != '\'')
             --cur;
           else
           {
             // ok, we have a ' -- but is this:  'asdf\'adsf'
             //                                        ^

             --cur; 

             if(*cur != '\\' )
             {
               ++cur;  // cur will get decremented later in a the outer loop so make sure
                       // the cursor is not already decrement once by mistake
               break;  
             }
             else
               --cur;
           }
        }

      } 
      else
      if(c == '"')
      { 

        // skip the trailing single quoted string
        // scan backwards from the last valid char in the string to the first
        // " in the string -- taking into account this kind of annoyance:  "\""
        //                                                                   ^
        
        --cur;

        while(cur != top)
        {
           char c = *cur;  // for debugging purposes

           (void)(c); // shut the stupid warning the F* off.

           if(*cur != '"')
             --cur;
           else
           {
             // ok, we have a ' -- but is this:  "asdf\"adsf"
             //                                        ^

             --cur; 

             if(*cur != '\\' )
             {
               ++cur;  // cur will get decremented later in a the outer loop so make sure
                       // the cursor is not already decrement once by mistake
               break;  
             }
             else
               --cur;
           }
        }

      } 

      if( (cur != top) && (*cur == '\n') )
      {
        // step back to the previous line and remove any c++ style comments on it

        --cur;

        TextIterator here(cur);

        char c = *cur;

        //        while( (cur != top) && (*cur != '\n') && (*cur != '"') && (*cur != '\'') )

        while( (cur != top) && (*cur != '\n') )
        {
          c = *cur;
          --cur;
        }

        // cur now sits at the beginning of the previous line -- scan forward until // is found
        // or until cur == here -- if // is found, stop and make that be 'here'

        for(;;)
        {
          if(cur == here)
            break;

          if(*cur == '/' && (cur != here) )
          {
            ++cur;

            if(cur != here && (*cur == '/'))
            {
               here = cur;
               break; 

               // leave here pointing to the comment -- it won't cause any trouble
            }

          }
          else
            ++cur;
        }

        cur = here;

        ++cur; // so the following decrement will work...
      }


      if(cur != top)
        --cur;
    }
  }
    
  if(cur == bot || cur == top)
  {
    //
    // found no match
    //
    vp->beep();
    return false;
  }


  cur_ = cur.line_;
  col_ = cur.col_;

  make_line_visible(vp,v);
  make_col_visible(vp,v);

  return false;
}


bool
Impl::
block_insert(viewport* vp, Viewer*v, input_event const *e)
{
  // if a block is marked, prompt the user for a string to
  // insert into the block at the current column.  Each marked line
  // gets the inserted text.


  if(first_mark_ == last_mark_)
  {
    vp->beep();
    return false;
  }

  CursorWindow::Dialog d("Enter a string to insert into the block");

  d += new CursorWindow::Dialog::String("name",
                                        "Text to insert",
                                        "",
                                        40
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok","");

  if(d.popup(vp->window()))
    return false;

  std::string text = d.element_value("name");

  if(text.size() == 0)
    return false;

  int i;

  UndoOperation* op = push_undo_stack();

  op->code_   =  UndoOperation::replace_block;
  op->lineno_ =  first_mark_;

  for(i=first_mark_; i < last_mark_; ++i)
  {
    std::string curline = line_text(i);

    op->block_.push_back(lines_[i]);

    if(curline.size() < col_)
    {
       size_t pad = col_ - curline.size();

       curline += std::string(pad, ' ');
    }

    curline.insert(col_, text);

    replace_line(i, curline, false);  // don't include undo info, we've done it alreay

  }

  paint_page(vp,v);

  return false;
}



bool
Impl::
block_adjust(viewport* vp, Viewer*v, input_event const *e)
{
  // Prompt the user for a number of columns to insert into the
  // marked block.  That is, insert a column of spaces at the current
  // cursor column into all lines in the marked block.

  if(first_mark_ == last_mark_)
  {
    vp->beep();
    return false;
  }

  CursorWindow::Dialog d("Insert/delete colums");

  d += new CursorWindow::Dialog::String("name",
                                        "Columns to insert/delete",
                                        "0",
                                        10
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok","");
                                
                                
  if(d.popup(vp->window()))
    return false;

  std::string text = d.element_value("name");

  if(text.size() == 0)
    return false;

  int adjustment =0;

  sscanf(text.c_str(), "%d", &adjustment);

  if(adjustment == 0)
    return false;


  int i;

  UndoOperation* op = push_undo_stack();

  op->code_   =  UndoOperation::replace_block;
  op->lineno_ =  first_mark_;

  std::string spaces_to_insert( adjustment > 0 ? adjustment : 0, ' ');

  for(i=first_mark_; i < last_mark_; ++i)
  {
    std::string curline = line_text(i);

    op->block_.push_back(lines_[i]);

    if(curline.size() < col_)
    {
       size_t pad = col_ - curline.size();

       curline += std::string(pad, ' ');
    }

    if(adjustment > 0)
      curline.insert(col_, spaces_to_insert);
    else
    {
      size_t line_length = curline.size();

      size_t chars_to_delete = -adjustment;

      if(col_ + chars_to_delete > line_length)
        chars_to_delete = line_length - col_;
        
      curline.erase(col_, chars_to_delete);

    }

    replace_line(i, curline, false);  // don't include undo info, we've done it alreay

  }

  paint_page(vp,v);

  return false;
}



AddMapping join_lines_func(CursorWindow::func_join, &Impl::line_join, Modifying);

bool
Impl::
line_join(viewport* vp, Viewer*v, input_event const *e)
{
  // join this line with the next line.

  if(size() == 0 || cur_ == size() - 1)
    return false;  // nothing to do, you can't join the end of the file to this line

  std::string next_line = line_text(cur_ + 1);

  std::string cur_line = line_text(cur_);

  if(next_line.size())
  {
    // next line is not blank -- remove leading blanks from that
    // line  -- there's no point in joining blanks.

    size_t col_tmp = cur_line.size();

    std::string::const_iterator first = next_line.begin(),
                                last  = next_line.end();
                                
    while(first != last && *first == ' ')
      ++first;

    {
      size_t s = first - next_line.begin();

      if(s)
        next_line.erase(0, first - next_line.begin());
    }

    // at this point, the local copy of the next line of text has
    // had leading blanks removed.  Now remove trailing blanks from cur_line

    first = cur_line.begin();
    last  = cur_line.end();

    while(first != last)
    {
      --last;

      if(*last != ' ')
      {
        ++last;
        break;
      }
    }

    // at this point, last points to the end of the string
    // or to the first blank character after the last non-blank
    // in cur_line

    {
       size_t new_length = (last - cur_line.begin());
       
       cur_line.erase( new_length, cur_line.size() - new_length);

       col_tmp = new_length;
    }

    cur_line += next_line;

    // cur_line is now the final product

    col_ = col_tmp;

  }

  UndoOperation* op = push_undo_stack();

  op->code_    = UndoOperation::break_lines;
  op->lineno_ = cur_;

  op->block_.push_back(std::string(lines_[cur_]));
  op->block_.push_back(std::string(lines_[cur_+1]));

  erase_line( lines_.find(cur_+1), cur_+1, false);
  erase_line( lines_.find(cur_), cur_, false);
  lines_.insert(lines_.find(cur_), new std::string(cur_line));

  make_col_visible(vp,v);
  make_line_visible(vp,v);
  paint_page(vp,v);

  return false;
}

AddMapping insert_lines_func(CursorWindow::func_insline, &Impl::line_insert, Modifying);

bool
Impl::
line_insert(viewport* vp, Viewer*v, input_event const *e)
{
  if(size() == 0)
  {
    lines_.insert(lines_.begin(), new std::string(""));
  }
  else
  {
    lines_.insert(lines_.find(cur_), new std::string(""));
  }

  push_undo_stack();
  undo_stack_.front()->code_   = UndoOperation::erase_line;
  undo_stack_.front()->lineno_ = cur_;


  make_line_visible(vp,v);
  paint_page(vp,v);

  return false;
}


AddMapping convert2edit(CursorWindow::func_to_edit, &Impl::to_edit, NonModifying);

bool
Impl::
to_edit(viewport* vp, Viewer*v, input_event const *e)
  // this function makes the current read only session writeable -- ie converts a 
  // view into an edit
{
  if(!is_writeable_)
  {
    is_writeable_ = true;
    paint_page(vp,v);
  }
  else
    vp->beep();

  return false;
}



AddMapping reread_edit(CursorWindow::func_reread, &Impl::reread, NonModifying);

bool
Impl::
reread(viewport* vp, Viewer*v, input_event const *e)
  // check to see if the file being edited has changed on disk.
{
  // cannot be undone!

  if(!fullname_.exists())
  {
    // if there's nothing to read, warn the user then quit.

    CursorWindow::Message d("Error reading file " + fullname_);
  
    d += "";
    d += "Press Enter to continue";
  
    d.popup(manager_->window());
  
    return false;
  }
  else
  {
     if(is_dirty_)
     {
       vp->beep();

       CursorWindow::Dialog d("Unsaved edit changes exist");

       d += new CursorWindow::Dialog::String("ok",
                                             "Discard them? (Yes or No)",
                                             "No",
                                             4
                                            );
       
       if(d.popup( manager_->window() ))
       {
         return false;
       }
       
       std::string ok_value = d.element_value("ok");
       
       if(ok_value.size() > 2)
       {
         ok_value.erase(2, ok_value.size());
       }
       
       if(ok_value != "Ye" && ok_value != "ye" )
       {
         vp->beep();
         return false;
       }
     }

     // we are going to reread the file -- so eliminate all the lines currently 
     // found -- and the block top and bottom -- 
     // and finally go to the top

     file_top(vp, v, e);

     first_mark_ = 0;
     last_mark_  = size();

     block_delete(vp, v, e);

     cur_ = 0;

     // size_t s = size();  // should be 0

     // now empty the undo stack

     while(!undo_stack_.empty())
     {
       delete undo_stack_.front();
       undo_stack_.pop_front();
     }

     read_file();

     make_line_visible(vp, v);

     paint_page(vp,v);

     return false;


  }


  return false;
}



struct is_colon
{
  bool operator() (char c) const { return c == ':'; }
};

struct is_pathsep
{
  bool operator() (char c) const { return c == '/' || c == '\\'; }
};


AddMapping switch_source_file(CursorWindow::func_switch, 
                              &Impl::switch_source, 
                              NonModifying);

bool
Impl::
switch_source(viewport* vp, Viewer*v, input_event const *e)
  // switch to an alternate file based on the current filename extension
  // and the directories listed in the SOURCEPATH and CDPATH environment
  // variables.  The filename extensions of interest are specified in
  // environment variable SOURCEALTS like this:
  //
  //   .c:.h:.:.inl:
  //
  // A single ., with no other lettering means that 'no extension' is 
  // meant -- such as the new c++ standard for system headers.
{
  StrTool::stringlist_t dirs;

  //
  // Collected needed environment variables and handle errors
  //

  std::string srcalts= ProgramOptions::global_options_->getenv("SOURCEALTS");
  std::string srcpath= ProgramOptions::global_options_->getenv("SOURCEPATH");
  std::string cdpath = ProgramOptions::global_options_->getenv("CDPATH");


  if(srcalts.size() == 0)
  {
    vp->beep();

    CursorWindow::Message d("SOURCEALTS environment variable is not set");

    d += "";
    d += "Set the SOURCEALTS environment variable to a colon";
    d += "separated list of file name extensions which count";
    d += "as source files";
    d += "";
    d += "For example:";
    d += "  SRCALTS=:.c:.h:.:.inl";
    d += "This example makes the following file name";
    d += "extensions valid source alternatives:";
    d += "  .c, .h, none, .inl";
    d += "";
    d += "Press Enter to continue";
    
    d.popup(manager_->window());
    
    return false;
  }


  if(srcpath.size() == 0 && cdpath.size() == 0)
  {
    vp->beep();

    CursorWindow::Message d("No SOURCEPATH or CDPATH set");
    
    d += "Please set one or both of the following";
    d += "environment variables:";
    d += "  SOURCEPATH";
    d += "  CDPATH";
    d += "Both variables are ':' separated lists";
    d += "directory names.";
    d += "";
    d += "Press Enter to continue";
    
    
    d.popup(manager_->window());
    
    return false;
  }

  //
  // Environent variables are good -- use them
  //

  StrTool::stringlist_t src_types;  // "srcalts split up (.c, .h, etc)"
  StrTool::stringlist_t src_dirs;   // "srcpath split up" + cdpath split up
  StrTool::stringlist_t src_path;   // "srcpath split up"
  StrTool::stringlist_t cd_dirs;    // "srcpath split up"

  src_dirs.push_back(".");

  StrTool::parse_words(srcalts, &src_types, 20000, is_colon());
  StrTool::parse_words(srcpath, &src_path,  20000, is_colon());
  StrTool::parse_words(cdpath,  &cd_dirs,  20000, is_colon());

  StrTool::stringlist_t::iterator sbegin, send;

  //
  // expand any directory name patters in the last basename's of src_path
  // elements
  //

  for(sbegin = src_path.begin(), send = src_path.end();
      sbegin != send;
      ++sbegin
     )
  {
    FileName cur(*sbegin);

    if(!cur.is_absolute_path())
    {
      cur = fullname_.dirname() + cur;
    }

    if(cur.basename() == "*")
    {
      FileName::sorted_names_t tmp;

      FileName::find_matching(cur, &tmp, 0x03);  
        // get directories only and full paths

      FileName::sorted_names_t::iterator a=tmp.begin(), b=tmp.end();
      while(a != b)
      {
        src_dirs.push_back(*a++);
      }

    }
    else
    {
      src_dirs.push_back(cur);
    }
  }

  //
  // include the cdpath in the src_dirs
  //
  for(sbegin = cd_dirs.begin(), send = cd_dirs.end();
      sbegin != send;
      ++sbegin
     )
  {
    src_dirs.push_back(*sbegin);
  }


  //
  // handle the 'none' file name extension
  //

  sbegin =  src_types.begin();
  send   =  src_types.end();

  while(sbegin != send)
  {
    if(*sbegin == ".")
      *sbegin = "";

    ++sbegin;
  }


  //
  //  Verify that this file is described by SOURCEALTS
  //

  std::string ext = fullname_.extension();
  std::string base= fullname_.basename(true);


  sbegin =  src_types.begin();
  send   =  src_types.end();

  while(sbegin != send)
  {
    if(ext == *sbegin)
      break;

    ++sbegin;
  }

  if(sbegin == send)
  {
    vp->beep();

    std::string tmp("  "); tmp += srcalts;

    CursorWindow::Message d("This file is not listed in SOURCEALTS");

    d += "In order to use the 'switch_source' editor function,";
    d += "you must be editing a file whose file name extension";
    d += "is listed in the environment variable, SOURCEALTS.";
    d += "";
    d += "That variable contains the following: ";
    d += tmp;
    d += "";
    d += "But you are editing a file whose extension is '" + ext + "'";
    d += "";
    d += "Press Enter to continue";

    d.popup(manager_->window());
    
    return false;
  }

  //
  // Find files matching the requirements
  //

  {
     typedef std::set<std::string> matches_t;

     matches_t matches;

     for(sbegin  =src_dirs.begin(),
           send  =src_dirs.end();
         sbegin != send;
         ++sbegin
        )
     {
        StrTool::stringlist_t::iterator f = src_types.begin(),
                                        l = src_types.end();
        while(f != l)
        {
          std::string cur_ext = *f;

          FileName test(*sbegin + "/" + base + cur_ext);

          if(test.exists() && !test.is_dir())
          {
            test.convert_to_absolute_path();
            matches.insert(test);
          }

          ++f;

        }
     }

     //
     // If less than 2 matches found, let user see the list of
     // source dirs
     //

     if(matches.size() < 2)
     {
       CursorWindow::Message d("FYI:  less than two matches found in the following dirs:");

       for(sbegin = src_dirs.begin(), send = src_dirs.end();
           sbegin != send;
           ++sbegin
          )
       {
         d += std::string("  ") + *sbegin;
       }

       d += "Press enter to continue";
     
       d.popup(manager_->window());
     }



     //
     //  Prompt the user with the list and let him select one
     //


     {
      CursorWindow::Selection d("Select an alternate source file below:");

      matches_t::iterator sbegin, send;

      for(sbegin = matches.begin(), send = matches.end();
          sbegin != send;
          ++sbegin
         )
      {
        d += *sbegin;
      }
  
      if(d.popup(manager_->window()))
        {
          return false;
        }

      //
      // Load the selected file into an editor
      // 

      {
        FileName file(d.selection_);

        Viewer* oldie = manager_->find_viewer(file);
      
        if(oldie)
        {
          manager_->activate(oldie);
        }
        else
        {
      
          Viewer* newbie = manager_->edit(file);
      
          if(newbie)
          {
            manager_->add(newbie, file);
      
          }
          else
            vp->beep();
        }
      
      }
      
     }
  }


  return false;
}

bool
Impl::
fetchAllLines(std::list< std::string > &output)
{
    rep_type::iterator first = lines_.begin(), last = lines_.end();

    while(first != last)
    {
        output.push_back(*first++);
    }

    return true;
}