viewermanager.cxx

Go to the documentation of this file.

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



#include <cxxtls/viewermanager.h>
#include <cxxtls/file.h>
#include <cxxtls/options.h>
#include <cxxtls/etagsdb.h>
#include <cxxtls/strtool.h>
#include <cxxtls/cursesinterface.h>
#include <cxxtls/user.h>
#include <cxxtls/cpptagdb.h>
#include <cxxtls/strtool.h>
#include <cxxtls/foreach.h>

#include <stdlib.h>
#include <portable_io.h>
#include <fstream>
#include <iomanip>

using namespace std;

namespace cxxtls
{

static int trash;

typedef CursorWindow::viewport::repaint_handler repaint_handler;

int ViewerManager::normal_att        = CursorWindow::normal;
int ViewerManager::active_title_att  = CursorWindow::reverse_bold;
int ViewerManager::inactive_title_att= CursorWindow::underlined;
int ViewerManager::active_mark_att   = CursorWindow::reverse_ul;
int ViewerManager::inactive_mark_att = CursorWindow::bold;
int ViewerManager::bottom_att        = CursorWindow::underlined;  // bottom line of viewport
int ViewerManager::highlighted_att   = CursorWindow::reversed;


class ViewerSelector
  //
  //
: public Viewer
{
public:

  size_t cur_row_;                 
  size_t display_top_;             
  int    first_row_;               
  bool   active_;

  ViewerSelector(ViewerManager* m)
  : Viewer(m),
    cur_row_(0),
    display_top_(0),
    first_row_(2),
    active_(true)
  {
    trash=2;
  }

  void operator() ( CursorWindow::viewport * vp,int cmd);

  bool handle_event( CursorWindow::input_event const * e,
                     CursorWindow::viewport          * vp
                   );

  static string app_name;

  string const &application_name() const { return app_name; }
                
  void repaint(CursorWindow::viewport *vp)
  {
     (*this)(vp, activate );
  }

  void output_row_text(CursorWindow::viewport * vp, int i)
  {
    // do not set the text attributes here!


    int maxw = vp->size().col_ - 15;

    if(i < (int)manager_->viewers_.size() )
    {
      string tmp = manager_->viewers_[i].first->application_name();

      if(tmp.size() > 10)
        tmp.erase(10,tmp.size());
        
      Viewer* viewer = manager_->viewers_[i].first;
        
      FileName thisfile(viewer->description());

      *vp << (viewer->is_dirty() ? "*" : " ")
          << std::setw(10) << tmp
          << "  " << thisfile.shorten(maxw)
          ;
    }
  }

  string description() const
  {
    return "Lets you choose a viewer";
  }
};

string ViewerSelector::app_name("ViewrSelct");


ViewerManager::
ViewerManager()
: active_viewport_(0),
  vs_(0),
  override_active_viewport_(10000),
  dir_opener_(0)
{
  setup_key_bindings();

  vs_.reset(new ViewerSelector(this));

  ViewerManager::normal_att        = CursorWindow::normal_att;
  ViewerManager::active_title_att  = CursorWindow::active_title_att;
  ViewerManager::inactive_title_att= CursorWindow::inactive_title_att;
  ViewerManager::active_mark_att   = CursorWindow::active_mark_att;
  ViewerManager::inactive_mark_att = CursorWindow::inactive_mark_att;
  ViewerManager::bottom_att        = CursorWindow::bottom_att;
  ViewerManager::highlighted_att   = CursorWindow::highlighted_att;


}

ViewerManager::
~ViewerManager()
{
  // delete the viewports, then the viewers

  vector<viewport*>::iterator vp_next = viewports_.begin(),
                                             vp_last = viewports_.end();

  while(vp_next != vp_last)
  {
    viewport* entry = *vp_next++;

    delete entry;

  }

  vector<vpentry>::iterator vr_next = viewers_.begin(),
                                 vr_last = viewers_.end();
                                        
  while(vr_next != vr_last)
  {
    vpentry &entry = *vr_next++;

    delete entry.first;

  }

  // close will occur automatically when the cw_ object is destroyed.
}

void
ViewerManager::
open()
{
  UserInfo me = UserInfo::get();

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

  tool_dir_ = tooldir;

  cw_.open();
}

void
ViewerManager::
close()
{
  cw_.close();
}

static bool jump2dir=false; // ^X^J means for bash to jump to a directory
                            // whose name is stored in ~/.tools_home/exitDir.txt
                            // when the program terminates.  You need a shell
                            // alias for edit to make this work.



void
ViewerManager::
recordExitDir() const
{
  if(jump2dir && exit_dir_.size())
  {
     FileName exitFileName( tool_dir_ + "/exitDir.txt" );

     ofstream exitFile(exitFileName.c_str());

     exitFile << exit_dir_ << endl;
  }
}

void
ViewerManager::
exit()
{
  cw_.close();

  recordExitDir();

  ::exit(0);
}


void
ViewerManager::
add(Viewer* v, string fullname)
{
  // a given viewer pointer can only appear in the viewers_ list once
  // which means the fullname is just a hint.

  vector<vpentry>::iterator first = viewers_.begin(),
                                 last = viewers_.end();

  while(first != last)
  {
    vpentry &entry = *first++;

    if(entry.first == v)
    {
       break;
    }

  }

  if(first == last)
  {
    // need to add a new viewer

    viewers_.push_back( vpentry(v, fullname) );

  }

  activate(v);  // do the magic to make it visible -- find a
                // viewport to put it in.

}




bool
ViewerManager::
activate(Viewer* v)
{

  vector<viewport*>::iterator vp_next = viewports_.begin(),
                              vp_last = viewports_.end();

  size_t count = 0;

  while(vp_next != vp_last)
  {
    viewport* entry = *vp_next++;

    repaint_handler *rh = entry->get_repaint_handler();

    Viewer* vp = dynamic_cast<Viewer*>(rh);

    if(vp == v)
    {
      // found it -- there is a viewport with this viewer in it.
      // make it the current viewport.

      entry->activate();
      override_active_viewport_ = count;

      std::string viewerName = find_viewer_name(vp);

      order_.activate( viewerName );

      return false;


    }

    ++count;

  }

  // No viewport has this viewer as its repaint_handler.
  // Replace the current viewer's repaint handler with this viewer


  vector<vpentry>::iterator vr_next = viewers_.begin(),
                            vr_last = viewers_.end();
                                        
  while(vr_next != vr_last)
  {
    vpentry &entry = *vr_next;

    if(entry.first == v)
      break;

    ++vr_next;

  }

  if(vr_next != vr_last)
  {
    // ok, viewer is valid, now replace the current viewport's repaint_handler
    // with the specified viewer

    if(active_viewport_ >= viewports_.size())
    {
      viewports_.push_back(cw_.new_viewport(v).release());
      active_viewport_ = viewports_.size() -1;
    }
    else
      viewports_[active_viewport_]->set_repaint_handler(v);

    viewports_[active_viewport_]->activate();

    repaint_handler *rh = viewports_[active_viewport_]->get_repaint_handler();

    Viewer* vp = dynamic_cast<Viewer*>(rh);

    std::string viewerName = find_viewer_name(vp);

    order_.activate( viewerName );

    return false;

  }


  return true;   // Darn, there is no such viewer.
}

void
ViewerManager::
vsplit(Viewer* v, string fullname)
{
  // a given viewer pointer can only appear in the viewers_ list once
  // which means the fullname is just a hint.

  if(viewports_.size())
  {
     // first, make sure that this viewer is not already in the list
     // if it is, and it isn't displayed, display it in the bottom
     // half window.  If it is already displayed, make that viewport
     // active.

     size_t i;

     for(i=0; i < viewports_.size(); ++i)
     {
       repaint_handler *rh = viewports_[i]->get_repaint_handler();

       Viewer* vp = dynamic_cast<Viewer*>(rh);

       if(vp == v)
       {
         // already displayed
        
         viewports_[i]->activate();
         active_viewport_ = i;
         return;
        
       }

     }

     // If we get here, it means that no viewport is already displaying
     // this viewer.  Check to see if there is an undisplayed viewer with
     // this address

     bool found=false;

     for(i=0; i < viewers_.size(); ++i)
     {
        if( viewers_[i].first == v )
        {
          found = true;
          break;
        }
     }

     if(!found)
     {
       // stick this viewer in the viewer's table

       viewers_.push_back( vpentry(v,fullname) );

     }


     // make sure this viewer is visible in the bottom of the current
     // viewport's space

     viewports_.push_back( viewports_[active_viewport_]->vsplit(v).release() );

     active_viewport_ = viewports_.size()-1;

     viewports_[active_viewport_]->activate();

  }
}


void
ViewerManager::
hsplit(Viewer* v, string fullname)
{
  // a given viewer pointer can only appear in the viewers_ list once
  // which means the fullname is just a hint.

  if(viewports_.size())
  {
     // first, make sure that this viewer is not already in the list
     // if it is, and it isn't displayed, display it in the right
     // half window.  If it is already displayed, make that viewport
     // active.

     size_t i;

     for(i=0; i < viewports_.size(); ++i)
     {
       repaint_handler *rh = viewports_[i]->get_repaint_handler();

       Viewer* vp = dynamic_cast<Viewer*>(rh);

       if(vp == v)
       {
         // already displayed
        
         viewports_[i]->activate();
         active_viewport_ = i;
         return;
        
       }

     }

     // If we get here, it means that no viewport is already displaying
     // this viewer.  Check to see if there is an undisplayed viewer with
     // this address

     bool found=false;

     for(i=0; i < viewers_.size(); ++i)
     {
        if( viewers_[i].first == v )
        {
          found = true;
          break;
        }
     }

     if(!found)
     {
       // stick this viewer in the viewer's table

       viewers_.push_back( vpentry(v,fullname) );

     }


     // make sure this viewer is visible in the right half of the current
     // viewport's space

     viewports_.push_back( viewports_[active_viewport_]->hsplit(v).release() );

     active_viewport_ = viewports_.size()-1;

     viewports_[active_viewport_]->activate();

  }
}


void
ViewerManager::
dispatch_event(ViewerManager::input_event const & event)
{
   // give event to the active viewport, if any.  If the
   // event handler returns true, it means the viewer needs
   // to be deleted -- so delete it.

   if(viewports_.size())
   {
      viewport* port = viewports_[active_viewport_];

      repaint_handler* rh = port->get_repaint_handler();

      Viewer* r = dynamic_cast<Viewer*>(rh);

      if(r->handle_event(&event, port))
      {
        std::string viewerName = find_viewer_name(r);

        order_.discard(viewerName);

        // first, close the viewport holding this viewer
        
        viewports_.erase( viewports_.begin() + active_viewport_ );
        
        delete port; // say goodnight dorothy, kansas just went bye bye
        
        // next remove the viewer from the viewer's list
        
        for(size_t i = 0; i < viewers_.size(); ++i)
        {
          if( viewers_[i].first == r )
          {
            viewers_.erase(viewers_.begin() + i );
            break;
          }
        }

        if(r != vs_.get())
        {
          // unless the viewer was the 'viewer selector', delete
          // the viewer.  The viewer selector hangs around forever...
        
          delete r;
        }
        
        if(viewers_.size() == 0)
        {
            exit();
        }
        else
        if(viewports_.size() == 0)
        {       
          // here we have lost our viewports but still have
          // some viewers hanging around (other than the
          // viewer selector which is handled as a special case
          // and never appears in the viewers_ array.
        
          active_viewport_ = 0;
        
          size_t youngest_viewer = viewers_.size() -1;

          MRU<std::string>::iterator mruPtr = order_.mostRecent();

          if(mruPtr != order_.end())
          {
             std::string mru = *mruPtr;

             for(size_t i = 0; i < viewers_.size(); ++i)
             {
                 if(mru == viewers_[i].second)
                 {
                    youngest_viewer = i;
                    break;
                 }
             }

          }

        
          viewports_.push_back(cw_.new_viewport
                                 ( viewers_[youngest_viewer].first ).release()
                              );

          viewports_[0]->activate();
        
        }
        
        if(override_active_viewport_ < viewports_.size())
        {
          // Handle an odd case in the appChooser::handle_event
          // where you choose viewer that already exists
          // and the 'active_viewport' causes a crash.
        
        
          active_viewport_ = override_active_viewport_;
        
          override_active_viewport_ = 10000;
        }

        
        if(active_viewport_ >= viewports_.size() )
        {
          active_viewport_ = viewports_.size() -1 ;
        }


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

        if(viewports_.size())
          viewports_[active_viewport_]->activate();
        
      }
      else
      {
        if(override_active_viewport_ < viewports_.size())
        {
          active_viewport_ = override_active_viewport_;
          override_active_viewport_ = 10000;
        
        }
      }

   }
}

list<string> ViewerManager::key_bindings_doc;

void
ViewerManager::
setup_key_bindings()
{
   // All view related master key bindings begin with ^V.

   master_key_map::sequence adder(master_keys_, new_application);
                            adder += 'X' - '@';  // ^X
                            adder += 'N' - '@';  // ^N
                            adder.complete();
   key_bindings_doc.push_back("^X ^N -- new application covering current viewer");

   master_key_map::sequence sheller(master_keys_, interactive_shell);
                            sheller += 'X' - '@';  // ^X
                            sheller += 'Z' - '@';  // ^Z
                            sheller.complete();
   key_bindings_doc.push_back("^X ^Z -- bring up an interactive shell");


   master_key_map::sequence addeditor(master_keys_, new_editor);
                            addeditor += 'X' - '@';  // ^X
                            addeditor += 'F' - '@';  // ^F
                            addeditor.complete();
   key_bindings_doc.push_back("^X ^F -- new editor covering current viewer");

   master_key_map::sequence addviewer(master_keys_, new_viewer);
                            addviewer += 'X' - '@';  // ^X
                            addviewer += 'V' - '@';  // ^V
                            addviewer.complete();
   key_bindings_doc.push_back("^X ^V -- new viewer covering current viewer");

   master_key_map::sequence vsplitter(master_keys_, horizontal_split);
                            vsplitter += 'X' - '@';  // ^X
                            vsplitter += '3';        // 3
                            vsplitter.complete();
   key_bindings_doc.push_back("^X ^3 -- split viewer horizontally");
                        
   master_key_map::sequence hsplitter(master_keys_, vertical_split);
                            hsplitter += 'X' - '@';  // ^X
                            hsplitter += '2';        // 2
                            hsplitter.complete();
   key_bindings_doc.push_back("^X ^2 -- split viewer vertically");
                        
   master_key_map::sequence unsplitter(master_keys_, unsplit);
                            unsplitter += 'X' - '@';  // ^X
                            unsplitter += '1';        // 1
                            unsplitter.complete();
   key_bindings_doc.push_back("^X ^1 -- unify screen (hide all but one viewer)");
                        
   master_key_map::sequence nexter(master_keys_, next);
                            nexter += 'X' - '@';  // ^X
                            nexter += 'o';        //  o
                            nexter.complete();
   key_bindings_doc.push_back("^X  o -- switch windows");

   master_key_map::sequence nexter1(master_keys_, next);
                            nexter1 += CursorWindow::key_f2;  // F2
                            nexter1.complete();
   key_bindings_doc.push_back("F2    -- switch windows");
                
   master_key_map::sequence helper(master_keys_, display_help);
                            helper += CursorWindow::key_f1;  // F1
                            helper.complete();
   key_bindings_doc.push_back("F1    -- get help");

                
//    master_key_map::sequence helper2(master_keys_, display_help);
//                             helper2 += 'H' - '@';  // ^H
//                             helper2.complete();
//    key_bindings_doc.push_back("^H    -- get help");
                
   master_key_map::sequence helper1(master_keys_, display_help);
                            helper1 += 'X' - '@';  // ^X
                            helper1 += 'H' - '@';  // ^H
                            helper1.complete();
   key_bindings_doc.push_back("^X ^H -- get help");
                
   master_key_map::sequence buffers(master_keys_, selector);
                            buffers += 'X' - '@';  // ^X
                            buffers += 'B' - '@';  // ^B
                            buffers.complete();
   key_bindings_doc.push_back("^X ^B -- select viewer from list");
                        
   master_key_map::sequence killer(master_keys_, die);
                            killer += 'X' - '@';  // ^X
                            killer += 'C' - '@';  // ^C
                            killer.complete();
   key_bindings_doc.push_back("^X ^C -- close all viewers and quit");

   master_key_map::sequence kill_and_jumper(master_keys_, die_and_jump);
                            kill_and_jumper += 'X' - '@';  // ^X
                            kill_and_jumper += 'J' - '@';  // ^J
                            kill_and_jumper.complete();
   key_bindings_doc.push_back("^X ^J -- same as ^C but leave curdir in ~/.tools_home/exitDir.txt");

                        
}

class appChooser
: public Viewer
{
public:


  size_t display_top_;
  size_t cur_row_;
  int    first_row_;
  bool   active_;

  appChooser(ViewerManager* vm)
  : Viewer(vm),
    display_top_(0),
    cur_row_(0),
    first_row_(2),
    active_(true)
  {
  }


  void operator() ( CursorWindow::viewport * vp,int cmd);

  bool handle_event( CursorWindow::input_event const * e,
                     CursorWindow::viewport          * vp
                   );

  void repaint(CursorWindow::viewport *vp)
  {
     (*this)(vp, activate );
  }

  void output_row_text(CursorWindow::viewport * vp, int i)
  {
    // do not set the text attributes here!

    if( (size_t) i < manager_->apps_.size() )
      *vp << manager_->apps_[i].second
          ;
  }

  static string app_name;

  string const& application_name() const { return app_name; }

  string description() const 
  {
    return "lets you run a new application";
  }
};

string appChooser::app_name("AppChooser");

void
ViewerManager::
handle_master_command(int cmd)
{
  // a master command is a command that involves window control.  Master
  // commands are handled directly by the viewer manager and are not sent to
  // individual viewers.

  switch(cmd)
  {
    //case vertical_split  :  vsplit(new appChooser(this), "appChooser"); return;
    //case horizontal_split:  hsplit(new appChooser(this), "appChooser"); return;

    case vertical_split  :  splitscreen_new_editor(false); return;
    case horizontal_split:  splitscreen_new_editor(true); return;

    case unsplit         :  unify();  return;
    case selector        :  vs(); return;
    case die             :  jump2dir=false; exit_dir_="" ; handle_die_request(); return;
    case die_and_jump    :  jump2dir=true;  exit_dir_="" ; handle_die_request(); return;
    case new_application :  add(new appChooser(this), "appchooser"); return;
    case new_viewer      :  popup_new_viewer(); return;
    case new_editor      :  popup_new_viewer(true); return;

    case next            :  {
                              if(viewports_.size() > 1)
                              {
                                // there are more than one viewports
                                // then 'switch windows' means to move
                                // to another visible viewport.  Basically
                                // it means moving to the created most
                                // recently before this one
                                
                                if(active_viewport_)
                                  --active_viewport_;
                                else
                                  active_viewport_ = viewports_.size() -1;
                                
                                viewports_[active_viewport_]->activate();

                                // after activating the viewport, which repaints it, flag the
                                // fullname associated withe the viewer as being the most recently
                                // used.

                                repaint_handler *rh =  viewports_[active_viewport_]->get_repaint_handler();
                                Viewer          *active = dynamic_cast<Viewer*>(rh);

                                for(size_t i = 0; i < viewers_.size(); ++i)
                                {
                                    if(viewers_[i].first == active)
                                    {
                                        order_.activate(viewers_[i].second);
                                        break;
                                    }
                                }


                              }
                              else
                              if(viewers_.size() > 1)
                              {
                                // if only one viewport is visible, switch
                                // out the viewer currently being shown.  So
                                // find a viewer which was created earlier
                                // than the one currently active viewer.
                                //
                                
                                Viewer* v = active_viewer();
                                
                                size_t i;
                                
                                for(i=0; i < viewers_.size(); ++i)
                                {
                                  if(viewers_[i].first == v)
                                  {
                                    break;
                                  }
                                }
                                
                                if(i == 0)
                                  i = viewers_.size() -1;
                                else
                                  --i;
                                
                                activate(viewers_[i].first);


                                order_.activate(viewers_[i].second);
                                
                              }
                              return;
                            }
    case display_help    :  help(); return;

    case interactive_shell:
                          {
                            row_col old_size;
                            row_col new_size;

                            int err;
                        
                            old_size = window()->size();
                            window()->close();
                        
                            string curdir = active_directory();
                            char old_dir[2000];

                            if( 0 == getcwd(old_dir, sizeof(old_dir)) )
                               old_dir[0] = 0;
                        
                            err = chdir(curdir.c_str());
                        
                            printf("Current directory is: ");
                            fflush(stdout);
                            err = system("pwd");

                            Viewer* av = active_viewer();

                                    
                        
#ifndef _MSC_VER
// unix
                            printf("\nThe file or directory you are working on is:\n  %s\n", 
                                     av?av->description().c_str():""
                                  );
                            printf("Starting your shell.  Please use 'exit' to return\n");
                            err = fflush(stdout);
                            {
                              char const *bash = getenv("BASH");
                        
                              if(bash)
                                err = system("bash -i");
                              else
                                err = system("/bin/sh -i");
                        
                            }
#else
// windows
                                  
                           err = system("cmd /c cls");
                            printf("\nThe file or directory you are working on is:\n  %s\n", 
                                     av?av->description().c_str():""
                                  );
                            printf("Starting CMD.EXE.  Please use 'exit' to return\n");
                           err = fflush(stdout);
                           err = system("cmd");
#endif

                            err =chdir(old_dir);

                            window()->open();
                            new_size = window()->size();
                            window()->resize_viewports(old_size, new_size);
                        
                            (void)(err);
                          }
                          return;

  }
}

void
ViewerManager::
run()
{
   // Prompt the user for input and handle his commands.  This may mean
   // direct interpretation of system level commands here or it may mean
   // directing keystrokes to the various command handlers in the viewers.

   if(viewports_.size() == 0)
   {
     Viewer* chooser = new appChooser(this);

     viewers_.push_back( vpentry(chooser, "appChooser") );

     viewports_.push_back( cw_.new_viewport(chooser).release() );

     viewports_.back()->activate();
   }

   CursorWindow::input_event e;

   //
   //  The run command lets the user enter keys.  It interprets patterns
   //  in these keys.  When a pattern is not recognized, it sends all the
   //  keys to the active viewport and goes back to the main input state.
   //

   for(;;)
   {
      // forever do:  read keys and intepret them

      // start of loop assumes we have no partial key pattern yet

      e = cw_.read_input();

      if(e.type_ != CursorWindow::input_event::DataKey &&
         e.type_ != CursorWindow::input_event::FunctionKey
        )
      {
        continue;  // fix this later, should be dispatching the
      }

      // we have just read a key

      master_key_map::search s(master_keys_);

      int possible_cmd;

      if(!s(e.value_))
      {
         // nope, this is not the first key of a pattern
        
         dispatch_event(e);
        
      }
      else
      if( (++s, s.finished(&possible_cmd) ) )
      {
        // handle the case of one character command sequences
        
        handle_master_command(possible_cmd);
      }
      else
      {
        // this is possibly the first key in a pattern -- read until
        // we find a pattern or if we don't.  If we don't, then send
        // send all the keys to the active viewport.  If we do, use
        // the pattern ourselves.
        
        vector<input_event> l;

        l.push_back(e);
        
        for(;;)
        {
          // read until sequence complete or invalid
        
          e = cw_.read_input();
        
          if(e.type_ != input_event::FunctionKey &&
             e.type_ != input_event::DataKey
            )
          {
            // something weird going on -- give all the keys to the
            // currently active viewer
        
            size_t i = 0;
        
            for(i=0; i < l.size(); ++i)
              dispatch_event(l[i]);
        
            dispatch_event(e);
        
            break;
          }
          else
          if(s(e.value_))
          {
            // this is a valid member of a sequence

            l.push_back(e);

            ++s;
        
            int id;

            if(s.finished(&id))
            {
               handle_master_command(id);
               break;
            }

          }
          else
          {
            // This new key ends the sequence
        
            size_t i = 0;
        
            for(i=0; i < l.size(); ++i)
              dispatch_event(l[i]);
        
            dispatch_event(e);

            break;
          }
        
        }
      }
   }
}




void
ViewerManager::
unify()
{
  // close all viewports but the currently active viewport and
  // give it full screen

  Viewer *viewer = dynamic_cast<Viewer*>
                       (viewports_[active_viewport_]->get_repaint_handler());

  size_t i;

  for(i = 0; i < viewports_.size(); ++i)
  {
     delete viewports_[i];
  }

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

  active_viewport_ = 0;

  viewports_.push_back(cw_.new_viewport(viewer).release());

  viewports_[active_viewport_]->activate();

}


void
ViewerManager::
vs()
{
  // replace the viewer in the current viewport with the viewer
  // selector viewer.

  //
  // make sure the viewer selector is not already up -- if it is,
  // make it the active viewport
  //
  size_t i;

  for(i=0; i < viewports_.size(); ++i)
  {
    repaint_handler* rh = viewports_[i]->get_repaint_handler();
    Viewer*          vp = dynamic_cast<Viewer*>(rh);

    if(vp == vs_.get())
    {
      active_viewport_ = i;
      viewports_[i]->activate();
      return;
    }
  }

  // ok, if we get here it means that the viewer selector is not up
  // so replace the viewer in the current viewport

  if(viewports_.size())
  {
    viewports_[active_viewport_]->set_repaint_handler(vs_.get());
    viewports_[active_viewport_]->activate();
    return;
  }

  // if we get here, it means there are no viewports.  This shouldn't
  // happen and it is harmless to ignore this case.

  return;

}


void
ViewerSelector::
operator() ( CursorWindow::viewport * vp,int cmd)
{
  // WARNING:  do not save vp -- it gets deleted regularly!

  // Handle screen repaint commands

  size_t  viewers = manager_->viewers_.size();
  row_col vpsize  = vp->size();
  row_col vporigin= vp->origin();

  if(cmd == CursorWindow::viewport::repaint_handler::activate)
    active_=true;
  else
  if(cmd == CursorWindow::viewport::repaint_handler::deactivate)
    active_=false;

  int left = 0;

  if(vporigin.col_)  ++left;  // if not left most viewer, add a 1 char bias

  // erase the viewport -- and underline the bottom line and the left
  // if necessary

  vp->set_text_attribute(ViewerManager::normal_att);

  vp->set_curpos(0,0);
  vp->fill_to_eos();

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

      // vp->write('|');

      using namespace CursesInterface;

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

  vp->set_curpos(vpsize.row_-1, left);
  vp->set_text_attribute(ViewerManager::bottom_att);
  vp->fill_to_eol();

  // display the title line highlighted based on active' flag
  // for this paint request

  vp->set_curpos(0,left);
  if(active_)
    vp->set_text_attribute(ViewerManager::active_title_att);
  else
    vp->set_text_attribute(ViewerManager::inactive_title_att);

  *vp << "Select one of " << viewers << " viewers";
  vp->fill_to_eol();

  // Draw the body of the window by representing each viewer
  // on one line of the display.  The viewer's address and shortname
  // and as much of the full name is presented as possible.

  // The display_top_ member indicates which row of the display is to
  // appear as the first entry in the vertical list of viewers
  // and the cur_row_ indicates which row the cursor is sitting on


  int row = first_row_;  // actual physical row where display occurs

  for(size_t  i = display_top_;
      row < vpsize.row_ && i < viewers;
      ++i, ++row
     )
  {

    vp->set_text_attribute(ViewerManager::normal_att); // set to normal atts

    if(row == vpsize.row_-1 && i != cur_row_)
    {
      vp->set_text_attribute(ViewerManager::bottom_att);
    }
    else
    if(i == cur_row_)
    {
      // highlight the current row by making it reversed video

      vp->set_curpos(row, left);
      vp->set_text_attribute(active_ ? ViewerManager::highlighted_att
                                     : ViewerManager::inactive_mark_att
                            );
      vp->fill_to_eol();

      // leave the text attributes as reversed
    }

    vp->set_curpos(row, 2+left);

    output_row_text(vp, i);

  }

  vp->set_text_attribute(ViewerManager::normal_att); // set to normal atts

  vp->set_curpos(first_row_ + cur_row_ - display_top_,left);
                          // leave cursor on current line of scrolling display

}

bool
ViewerSelector::
handle_event( CursorWindow::input_event const * e,
              CursorWindow::viewport          * vp
            )
{
  //
  //  The ViewerSelector event handler lets you select a viewer
  //  and make the 'active'.
  //

   if(e->type_ == CursorWindow::input_event::ForceExitKey)
     return true; // terminate the window


   if(e->type_ != CursorWindow::input_event::DataKey &&
      e->type_ != CursorWindow::input_event::FunctionKey
     )
     return false;

   // unhighlight the current line to be ready for a line
   // change

   int     row      = first_row_ + (cur_row_ - display_top_); // screen row
   row_col size     = vp->size();
   row_col vporigin = vp->origin();

   int bottom_row   = size.row_ - first_row_ - 1;

   int left = 0;

   if(vporigin.col_)  ++left;  // if not left most viewer, add a 1 char bias

   vp->set_curpos(row,left);
   vp->set_text_attribute(row == bottom_row ? ViewerManager::bottom_att
                                            : ViewerManager::normal_att);

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();

   int edit_func = vp->window()->func[e->value_];

   switch(edit_func)
   {
     case CursorWindow::func_top:
       row = first_row_;
       cur_row_ = 0;
       display_top_ = 0;
       vp->activate();
       break;

     case CursorWindow::func_bottom:
       row = first_row_;
       cur_row_ = manager_->viewers_.size()-1;

       if( (int) cur_row_ < 0)
         cur_row_ = 0;
        
       display_top_ = cur_row_;
       vp->activate();
       break;

     case CursorWindow::func_up:

       // move the cursor up one line and handle paging issues

       if(row == first_row_)
       {
         if(cur_row_ > 0)
         {
           // step up a row
        
           int page_length = size.row_ - first_row_;
        
           display_top_ -= page_length;
        
           if( (int) display_top_ < 0)
             display_top_ = 0;
        
           cur_row_ = display_top_ + page_length-1;
        
           if(cur_row_ >= manager_->viewers_.size())
           {
             cur_row_ = manager_->viewers_.size() -1;
           }
        
           if( (int)(cur_row_) < 0 )
             cur_row_ = 0;
        
           row = first_row_ + (cur_row_ - display_top_);
        
           repaint(vp);
         }
       }
       else
       {
         --row;
         --cur_row_;
       }

       break;
     case CursorWindow::func_down:

       // move the cursor down one line and handle paging issues

       if(row == size.row_ - 1)
       {
         // at bottom of current viewport
         // page forward
        
         row = first_row_;

         display_top_  += size.row_ - first_row_;
        
         if( (int)(display_top_) >= (int)(manager_->viewers_.size()))
         {
           display_top_ -= size.row_ - first_row_ -1;
        
           if( ((int)display_top_) < 0 )
             display_top_ = 0;
         }
        
         cur_row_ = display_top_;
        
        repaint(vp);
        
       }
       else
       {
         // not at bottom of viewport
        
         if(cur_row_ < manager_->viewers_.size()-1)
         {
           ++row;
           ++cur_row_;
         }
       }
       break;
     case CursorWindow::func_prior:

       // move the cursor back one page and handle paging issues

       display_top_ -= size.row_ - first_row_;

       if( (int)(display_top_) < 0)
         display_top_ = 0;
        
       cur_row_ = display_top_;

       row = first_row_;

       repaint(vp);

       break;

     case CursorWindow::func_next:

       // move the cursor forward one page and handle paging issues

       display_top_ += size.row_ - first_row_;

       if( (int)(display_top_) >= (int)manager_->viewers_.size() )
         display_top_ = manager_->viewers_.size()-1;
        
       if( (int)(display_top_) < 0 )
         display_top_ = 0;
        
       cur_row_ = display_top_;

       row = first_row_;

       repaint(vp);

       break;

     case CursorWindow::func_clreol:  // ^K
       goto undisplay_viewer_selector;

     case CursorWindow::func_enter:

       // Activate the viewer indicated by the current line onto
       // the screen.  If there is no viewport currently showing
       // that viewerr, replace the viewer in the current viewport
       // with the selected viewer (displacing the viewer selector).
       {
          Viewer* selectee = manager_->viewers_[cur_row_].first;

          manager_->order_.activate( manager_->viewers_[cur_row_].second );
        
          vector<viewport*> &viewports_ = manager_->viewports_;
        
          size_t i;
        
          bool found=false;
        
          for(i = 0; i < viewports_.size(); ++i)
          {
            repaint_handler *rh =  viewports_[i]->get_repaint_handler();
        
            Viewer* vp = dynamic_cast<Viewer*>(rh);
        
            if(vp == selectee)
            {

              viewports_[i]->activate();
              manager_->active_viewport_ = i;
              found = true;
              return false;
            }
          }
        
          if(!found)
          {
            // no viewport is currently showing the viewer --
            // give it the space used by this viewer selector
        
            viewports_[manager_->active_viewport_]->set_repaint_handler(selectee);
            viewports_[manager_->active_viewport_]->activate();
        
            return false;
        
          }
        
       }
       break;

     case CursorWindow::func_data:
       switch(e->value_)
       {
         case 'q':  // undisplay the viewer selector
           {
undisplay_viewer_selector:
        
        
             size_t &active_viewport_ = manager_->active_viewport_;
        
             vector<CursorWindow::viewport*> &viewports_ = manager_->viewports_;
        
             delete viewports_[active_viewport_];

             viewports_.erase(viewports_.begin() + active_viewport_);
        
             if(active_viewport_ >= viewports_.size())
               active_viewport_ = viewports_.size() -1 ;
        
             if( ((int)active_viewport_) < 0 )
               active_viewport_ = 0;
        
             if( viewports_.size() )
             {
               viewports_[active_viewport_]->activate();
             }
             else
             {
               vector<ViewerManager::vpentry> &viewers_ =
                                                            manager_->viewers_;
        
               if( viewers_.size() == 0 ||
                    (
                      viewers_.size() == 1 &&
                      viewers_[0].first == this
                    )
                 )
                 manager_->exit();  // either no viewers left or only the viewer selector
               else
                 viewports_.push_back(manager_->
                                         cw_.new_viewport(viewers_[0].first).release());
                
               viewports_[0]->activate();
                
             }
        
             return false;
           }
           break;
       }
       break;


   }

   // now, highlight the appropriate line

   vp->set_curpos(row,left);
   vp->set_text_attribute(ViewerManager::highlighted_att);

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();

   vp->set_curpos(row,left);
   vp->set_text_attribute(row == bottom_row ? ViewerManager::bottom_att
                                            : ViewerManager::normal_att);

   return false;
}



void
appChooser::
operator() ( CursorWindow::viewport * vp,int cmd)
{
  // WARNING:  do not save vp -- it gets deleted regularly!

  // Handle screen repaint commands

  if(cmd == CursorWindow::viewport::repaint_handler::activate)
    active_ = true;
  else
  if(cmd == CursorWindow::viewport::repaint_handler::deactivate)
    active_ = false;

  size_t  apps = manager_->apps_.size();
  row_col vpsize  = vp->size();
  row_col vporigin= vp->origin();

  int left = 0;

  if(vporigin.col_)  ++left;  // if not left most viewer, add a 1 char bias

  // erase the viewport -- and underline the bottom line
  vp->set_text_attribute(ViewerManager::normal_att);
  vp->set_curpos(0,0);
  vp->fill_to_eos();

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

      using namespace CursesInterface;

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


  vp->set_curpos(vpsize.row_-1, left);
  vp->set_text_attribute(ViewerManager::bottom_att);
  vp->fill_to_eol();

  // display the title line highlighted based on active' flag
  // for this paint request

  vp->set_curpos(0,left);

  if(active_)
    vp->set_text_attribute(ViewerManager::active_title_att);
  else
    vp->set_text_attribute(ViewerManager::inactive_title_att);

  *vp << "Select one of " << apps << " applications";
  vp->fill_to_eol();

  // Draw the body of the window by representing each application
  // on one line of the display.  The application's address and shortname
  // and as much of the full name is presented as possible.

  // The display_top_ member indicates which row of the display is to
  // appear as the first entry in the vertical list of apps
  // and the cur_row_ indicates which row the cursor is sitting on


  int row = first_row_;  // actual physical row where display occurs

  for(size_t  i = display_top_;
      row < vpsize.row_ && i < apps;
      ++i, ++row
     )
  {

    vp->set_text_attribute(ViewerManager::normal_att); // set to normal atts

    if(row == vpsize.row_-1 && i != cur_row_)
    {
      vp->set_text_attribute(ViewerManager::bottom_att);
    }
    else
    if(i == cur_row_)
    {
      // highlight the current row by making it reversed video

      vp->set_curpos(row, left);
      vp->set_text_attribute(ViewerManager::highlighted_att);
      vp->fill_to_eol();

      // leave the text attributes as reversed
    }

    vp->set_curpos(row, 2+left);

    output_row_text(vp, i);

  }

  vp->set_text_attribute(ViewerManager::normal_att); // set to normal atts

  vp->set_curpos(first_row_ + cur_row_ - display_top_,left);
                          // leave cursor on current line of scrolling display

}

bool
appChooser::
handle_event( CursorWindow::input_event const * e,
              CursorWindow::viewport          * vp
            )
{
  //
  //  The appChooser event handler lets you select a application
  //  replace the chooser with that application in the same viewport.
  //

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

   if(e->type_ != CursorWindow::input_event::DataKey &&
      e->type_ != CursorWindow::input_event::FunctionKey
     )
     return false;

   if(manager_->apps_.size() == 0)
     return true;

   // unhighlight the current line to be ready for a line
   // change

   int     row  = first_row_ + (cur_row_ - display_top_); // screen row
   row_col size = vp->size();
   row_col vporigin= vp->origin();

   int left = 0;

   if(vporigin.col_)  ++left;  // if not left most viewer, add a 1 char bias

   vp->set_curpos(row,left);
   vp->set_text_attribute(ViewerManager::normal_att);

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();

   int edit_func = vp->window()->func[e->value_];

   switch(edit_func)
   {
     case CursorWindow::func_top:
       row = first_row_;
       cur_row_ = 0;
       display_top_ = 0;
       vp->activate();
       break;

     case CursorWindow::func_bottom:
       row = first_row_;
       cur_row_ = manager_->viewers_.size()-1;

       if( (int) cur_row_ < 0)
         cur_row_ = 0;
        
       display_top_ = cur_row_;
       vp->activate();
       break;
     case CursorWindow::func_up:

       // move the cursor up one line and handle paging issues

       if(row == first_row_)
       {
         if(cur_row_ > 0)
         {
           // step up a row
        
           int page_length = size.row_ - first_row_;
        
           display_top_ -= page_length;
        
           if( (int) display_top_ < 0)
             display_top_ = 0;
        
           cur_row_ = display_top_ + page_length-1;
        
           if(cur_row_ >= manager_->apps_.size())
           {
             cur_row_ = manager_->apps_.size() -1;
           }
        
           if( (int)(cur_row_) < 0 )
             cur_row_ = 0;
        
           row = first_row_ + (cur_row_ - display_top_);
        
           repaint(vp);
        
         }
       }
       else
       {
         --row;
         --cur_row_;
       }

       break;
     case CursorWindow::func_down:

       // move the cursor down one line and handle paging issues

       if(row == size.row_ - 1)
       {
         // at bottom of current viewport
         // page forward
        
         row = first_row_;

         display_top_  += size.row_ - first_row_;
        
         if( (int)(display_top_) >= (int)(manager_->apps_.size()))
         {
           display_top_ -= size.row_ - first_row_ -1;
        
           if( ((int)display_top_) < 0 )
             display_top_ = 0;
         }
        
         cur_row_ = display_top_;
        
        repaint(vp);
        
       }
       else
       {
         // not at bottom of viewport
        
         if(cur_row_ < manager_->apps_.size()-1)
         {
           ++row;
           ++cur_row_;
         }
       }
       break;
     case CursorWindow::func_prior:

       // move the cursor back one page and handle paging issues

       display_top_ -= size.row_ - first_row_;

       if( (int)(display_top_) < 0)
         display_top_ = 0;
        
       cur_row_ = display_top_;

       row = first_row_;

       repaint(vp);

       break;

     case CursorWindow::func_next:

       // move the cursor forward one page and handle paging issues

       display_top_ += size.row_ - first_row_;

       if( (int)(display_top_) >= (int)manager_->apps_.size() )
         display_top_ = manager_->apps_.size()-1;
        
       if( (int)(display_top_) < 0 )
         display_top_ = 0;
        
       cur_row_ = display_top_;

       row = first_row_;

       repaint(vp);

       break;


     case CursorWindow::func_enter:
       {
          //
          // Invoke the current application to get a viewer, then replace
          // this appChooser instance with the viewer -- finally deleting
          // self.
          //
          ViewerManager::application app = manager_->apps_[cur_row_].first;
        
          string fullname;
        
          Viewer* rv = (*app)(manager_, fullname);
        
          if(rv)
          {
            // A viewer was returned -- ie the user didn't abort any
            // needed input.  So, replace this appChooser with the
            // new viewer.
        
            {
              // see if the returned viewer is a viewer that has already
              // found in the viewers list.  If so, kill this window and
              // activate tht one
        
              for(size_t i=0; i < manager_->viewers_.size(); ++i)
              {
                if(manager_->viewers_[i].first == rv)
                {
                  manager_->activate(rv);
                
                  {
                      for(i = 0; i < manager_->viewports_.size(); ++i)
                      {
                        if(manager_->viewports_[i]->get_repaint_handler() == rv)
                        {
                          manager_->override_active_viewport_ = i;
                          break;
                        }
                      }
                  }
                
                  return true;
                }
              }
        
            }
        
        
            size_t i;
        
            typedef ViewerManager::vpentry  vpentry;
        
            vector<viewport*> &viewports_ = manager_->viewports_;
            vector<vpentry>   &viewers_   = manager_->viewers_;
        
            viewports_[manager_->active_viewport_]->set_repaint_handler(rv);
        
        
            for(i=0; i < viewers_.size(); ++i)
            {
               if(viewers_[i].first == this)
               {
                  viewers_[i].first = rv;
                  viewers_[i].second = fullname;
                
                  viewports_[manager_->active_viewport_]->activate();
                
                  return false;
               }
            }
          }
        
          return true;
        
       }
       break;

     case CursorWindow::func_data:
       switch(e->value_)
       {
         case 'q':  // undisplay the application chooser
           return true;
       }
       break;


   }

   // now, highlight the appropriate line

   vp->set_curpos(row,left);
   vp->set_text_attribute(ViewerManager::highlighted_att);

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();

   vp->set_curpos(row,left);
   vp->set_text_attribute(ViewerManager::normal_att);

   return false;
}

Viewer*
ViewerManager::
find_viewer(string const &viewername)
{
  for(size_t i=0; i < viewers_.size(); ++i)
  {
    if( viewers_[i].second == viewername)
      return viewers_[i].first;
  }

  return 0;
}



std::string
ViewerManager::
find_viewer_name(Viewer *vp)
{
  for(size_t i=0; i < viewers_.size(); ++i)
  {
    if( viewers_[i].first == vp)
      return viewers_[i].second;
  }

  return std::string();
}


void
ViewerManager::
help()
{
  Viewer* active = active_viewer();

  active->help();

}



void
ViewerManager::
help_helper( list<string>& help_info )
{
  CursorWindow::Message m("Help");

  //
  // First, make sure the current viewer's help is first in the display
  //

  {
    list< string >::iterator first = help_info.begin(),
                                       last  = help_info.end();
                                
    while(first != last)
    {
      string &t = *first++;

      m += t;

    }
  }


  // now attach the system command bindings help info (viewer manager specific
  // stuff

  m += "";
  m += string("Executable: ") + executable_name_ + ":" ;
  m += "    " + executable_version_;
  m += "";
  m += "System command bindings are as follows:";
  m += "";

  {
    list<string>::iterator first = key_bindings_doc.begin(),
                                     last  = key_bindings_doc.end();
                                
    while(first != last)
    {
      string &s = *first++;

      m += "  " + s;

    }
  }

  m += "";
  m += "Standard edit function key bindings";
  m += "  (some may not apply):";
  m += "";

  {
    CursorWindow* window = this->window();

    map<int,int>::iterator first = window->func.begin(),
                                last  = window->func.end();
    while(first != last)
    {
      map<int,int>::value_type& cur = *first++;

      int key = cur.first;
      int func= cur.second;

      if(func != CursorWindow::func_data)
      {

        string key_name  = CursorWindow::key_name(key);
        string func_name = CursorWindow::func_name(func);
        
        while(key_name.size() < 8)
          key_name += ' ';
        
        m += string("  ") + key_name + string(" -- ") + func_name;
      }

    }


  }



  m.popup(window());

}


Viewer*
ViewerManager::
open(string const &_fullname)
{
  FileName fullname(_fullname);

  if(fullname.is_dir())
  {
    if(!dir_opener_)
      return 0;

    return (*dir_opener_)(this, fullname);

  }
  else
  {
    // see if the specified name's basename contains '*' or '?'

    string basepart = fullname.basename();

    string::iterator first = basepart.begin(),
                          last  = basepart.end();
                        
    while(first != last)
    {
      char c = *first++;

      if(c == '*' || c == '?')
      {
        if(!dir_opener_)
          return 0;

        return (*dir_opener_)(this, fullname);
      }
    }

  }

  // ok, its not a directory or a directory search pattern


  string ext = fullname.extension();

  if(ext.size())
  {
    list<opener_map_entry>::iterator first = openers_.begin(),
                                     last  = openers_.end();
                                        
    while(first != last)
    {
      opener_map_entry & cur = *first++;

      std::string const &supported = cur.second;


      if(supported == ext)
        return (*cur.first)(this, fullname);
    }

    // no file extension specific match occurred

  }

  if(openers_.begin() != openers_.end())
  {
    application app= openers_.back().first;

    return (*app)(this, fullname);

  }


  return 0;


}

void
ViewerManager::
set_directory_app(application a)
{
  dir_opener_ = a;
}

void
ViewerManager::
add_viewer_app(application a, string filename_extension)
{
  openers_.push_front( opener_map_entry(a,filename_extension) );
}

void
ViewerManager::
add_editor_app(application a, string filename_extension)
{
  editors_.push_front( opener_map_entry(a,filename_extension) );
}

Viewer*
ViewerManager::
edit(string const &_fullname)
{
  FileName fullname(_fullname);

  if(fullname.is_dir())
  {
    if(!dir_opener_)
      return 0;

    string name = fullname + "/*";

    return (*dir_opener_)(this, name);

  }
  else
  {
    // see if the specified name's basename contains '*' or '?'

    string basepart = fullname.basename();

    string::iterator first = basepart.begin(),
                          last  = basepart.end();
                        
    while(first != last)
    {
      char c = *first++;

      if(c == '*' || c == '?')
      {
        if(!dir_opener_)
          return 0;

        return (*dir_opener_)(this, fullname);
      }
    }

  }

  // ok, its not a directory or a directory search pattern


  string ext = fullname.extension();

  if(ext.size())
  {
    list<opener_map_entry>::iterator first = editors_.begin(),
                                          last  = editors_.end();
                                        
    while(first != last)
    {
      opener_map_entry & cur = *first++;

      std::string const &supported = cur.second;

      if(supported == ext)
        return (*cur.first)(this, fullname);
    }

    // no file extension specific match occurred

  }

  if(editors_.begin() != editors_.end())
  {
    // look for the editor with an empty string as its extension
    // and if that is not found, look for the last one .

    application app= 0;

    list<opener_map_entry>::iterator first = editors_.begin(),
                                          last  = editors_.end();
                                        
    while(first != last)
    {
      opener_map_entry & cur = *first++;

      if(cur.second == "")
      {
        app = cur.first;
        break;
      }
    }
    
    if(app == 0)
        app= editors_.back().first;

    return (*app)(this, fullname);

  }


  return 0;


}

string
ViewerManager::
active_directory() const
{
  ViewerManager* me = const_cast<ViewerManager*>(this);

  Viewer* av = me->active_viewer();

  FileName pattern;

  if(!av)
    pattern="/";
  else
  {
    vector<vpentry>::iterator first = me->viewers_.begin(),
                                   last  = me->viewers_.end();
                                
    while(first != last)
    {
      vpentry& e = *first;

      if(e.first == av)
      {
        pattern=e.second;
        pattern = pattern.dirname();
        
        break;
      }

      ++first;

    }

    if(first == last)
    {
      pattern="/";
    }

  }

  return pattern;

}


void
ViewerManager::
popup_new_viewer(bool use_edit)
{
  FileName pattern = active_directory();

  // NOTE:  do NOT use the CursorWindow::FileSelector here because it can't
  // repaint the screen from this context and it needs to.

  CursorWindow::Dialog d( use_edit ? "Edit file or directory"
                                   : "View file or directory"
                        );

  d.set_completion_directory(pattern);
        
   d += new CursorWindow::Dialog::String("name",
                                         "Pathname",
                                         "",
                                         40
                                        );
                                
   if(d.popup(window()))
     return ;
        
  string file = d.element_value("name");


  if(file.size())
  {
     FileName f(file);

     f = f.expand_tildes();  // expand ~lboggs

     if(!f.is_absolute_path())
       f = pattern + f;

     f.convert_to_absolute_path();

     if(f.is_dir())
     {
       char lastChar = f[f.size()-1];

       if(lastChar != '/' && lastChar != '\\')
         f += '/';

       f += '*';
     }

     Viewer* extant_viewer = find_viewer(f);

     if(extant_viewer)
     {
       activate(extant_viewer);

       if(override_active_viewport_ < viewports_.size())
       {
         active_viewport_ = override_active_viewport_;
         override_active_viewport_ = 10000;
       }

       return;
     }

     Viewer* newbie;

     if(use_edit)
       newbie = edit(f);
     else
       newbie = open(f);

     if(newbie)
       add(newbie, f);

  }

}

bool
ViewerManager::
is_visible(Viewer* v)
{

  vector<viewport*>::iterator vp_next = viewports_.begin(),
                                   vp_last = viewports_.end();

  while(vp_next != vp_last)
  {
    viewport* entry = *vp_next++;

    repaint_handler *rh = entry->get_repaint_handler();

    Viewer* vp = dynamic_cast<Viewer*>(rh);

    if(vp == v)
    {
      // found it -- there is a viewport with this viewer in it.
      // make it the current viewport.

      return true;

    }

  }

  return false;
}


void
ViewerManager::
splitscreen_new_editor(bool horizontal)
{
  FileName pattern = active_directory();

  string title;

  if(horizontal)
    title = "Horizontally ";
  else
    title = "Vertically ";

  title += "Split window and edit (leave name blank for buffer list)";

  CursorWindow::Dialog d(title);

  d.set_completion_directory(pattern);
        
   d += new CursorWindow::Dialog::String("name",
                                         "Pathname",
                                         "",
                                         40
                                        );
                                
   if(d.popup(window()))
     return ;
        
  string file = d.element_value("name");

  // remove leading spaces from the file name

  while( file.size() && file[0] == ' ')
    file.erase( file.begin() );

  // if the file name is empty, bring up the viewer
  // selector, otherwise bring up an edit session

  if(file.size() == 0)
  {
    //
    // make sure the viewer selector is not already up -- if it is,
    // make it the active viewport
    //
    size_t i;

    for(i=0; i < viewports_.size(); ++i)
    {
      repaint_handler* rh = viewports_[i]->get_repaint_handler();
      Viewer*          vp = dynamic_cast<Viewer*>(rh);

      if(vp == vs_.get())
      {
        active_viewport_ = i;
        viewports_[i]->activate();
        return;
      }
    }

    // ok, if we get here it means the the user enter an empty
    // file name and the viewer selector is not currently
    // displayed.

    if(horizontal)
      hsplit(vs_.get(), "Viewer Selector");
    else
      vsplit(vs_.get(), "Viewer Selector");


  }
  else
  {
     FileName f(file);

     if(!f.is_absolute_path())
       f = pattern + f;

     f.convert_to_absolute_path();

     if(f.is_dir())
       f += "/*";

     Viewer* extant_viewer = find_viewer(f);

     if(extant_viewer)
     {
       if(is_visible(extant_viewer))
       {
         activate(extant_viewer);
        
         if(override_active_viewport_ < viewports_.size())
         {
           active_viewport_ = override_active_viewport_;
           override_active_viewport_ = 10000;
         }
       }
       else
       {
         if(horizontal)
           hsplit(extant_viewer, f);
         else
           vsplit(extant_viewer, f);
       }
       return;
     }

     Viewer* newbie;

     newbie = edit(f);

     if(newbie)
     {
       if(horizontal)
         hsplit(newbie, f);
       else
         vsplit(newbie, f);
     }

  }

}

void
ViewerManager::
handle_die_request()
{
   // close all windows that can be closed

   string curdir=active_directory();

   if(exit_dir_.size() == 0)
   {
     exit_dir_ = curdir;
   }

   bool clean_viewer_found=true;

   while(clean_viewer_found)
   {
     size_t viewers = viewers_.size();

     clean_viewer_found = false;

     for(size_t i=0; i < viewers; ++i)
     {
       if(!viewers_[i].first->is_dirty())
       {
         CursorWindow::input_event e;  
                                   
         e.type_ = CursorWindow::input_event::ForceExitKey;
     
         activate(viewers_[i].first);

         dispatch_event(e);


         clean_viewer_found = true;

         break; // leave the loop so that each time a 'kill' is sent to a viewer
                // we restart with viewerport 0 while searching
       }
     }

   }

   if(viewers_.size() == 0)
   {
     recordExitDir();  // won't do it if jump2dir is false

     exit();

   }

   unify();  

   {
       active_viewport()->beep();

       CursorWindow::Message m("Unsaved edit changes exist");

       m += "  You must manually close all edit sessions";
       m += "  with unsaved changes";

       m.popup(window());
   }



}

string 
ViewerManager::
default_etags_path(string &default_etags_path, char const *tagfileName)
{
   //
   //  Return a pathname for the TAGS file
   //

   string etagspath = ProgramOptions::global_options_->getenv("ETAGSPATH");
   string home      = ProgramOptions::global_options_->getenv("HOME");
   string cdpath    = ProgramOptions::global_options_->getenv("CDPATH");

   if(cdpath.size())
    {
      default_etags_path += cdpath;
      default_etags_path += FileName::PATH_separator;
    }

   default_etags_path += ".";
   default_etags_path += FileName::PATH_separator;
   default_etags_path += "..";
   default_etags_path += FileName::PATH_separator;
   default_etags_path += home;

   if(etagspath.size())
   {
     default_etags_path = etagspath;
   }

   FileName tagsfile = FileName::find_file_in_path(tagfileName, default_etags_path);

   return tagsfile;

}

EtagsDB*
ViewerManager::default_etags_db()
{
  static EtagsDB* rv = 0;

  if(rv == 0)
  {
    rv = new EtagsDB;

    string tagsfile;

    string default_etags_path;

    tagsfile = ViewerManager::default_etags_path(default_etags_path);

    rv->set_tags_file(tagsfile);

    if(!rv->ok())
    {
      string sp("  ");
    
      CursorWindow::Message  m("Error opening 'TAGS' file");
    
      m += "Couldn't find the TAGS file in any directory defined by $ETAGSPATH:";
    
      StrTool::stringlist_t l;
    
      string default_etags_path;
    
      ViewerManager::default_etags_path(default_etags_path);
    
      StrTool::parse_words(default_etags_path, &l, 10000, FileName::is_separator());
    
      StrTool::stringlist_t::iterator first = l.begin(),
                                      last  = l.end();
                                  
      while(first != last)
      {
        m += *first++;
      }
    
      active_viewport()->beep();
    
      m.popup(active_viewport()->window());
    
      return 0;
    }


  }

  return rv;
}

CppTagDB::Info*
ViewerManager::default_cpptags_db()
{
  static CppTagDB::Info* rv = 0;

  if(rv == 0)
  {
    rv = new CppTagDB::Info;

    string path;

    string tagppFile = default_etags_path(path,"TAGPP.tagpp");

    int failedLine=-1;

    int err = rv->populate(tagppFile, failedLine);

    if(err)
    {
      string sp("  ");
    
      CursorWindow::Message  m("Error opening TAGPP.tagpp file");
    
      m += "Couldn't find the TAGPP.tagpp file in any directory defined by $ETAGSPATH:";
    
      StrTool::stringlist_t l;
    
      string default_etags_path;
    
      StrTool::parse_words(path, &l, 10000, FileName::is_separator());
    
      StrTool::stringlist_t::iterator first = l.begin(),
                                      last  = l.end();
                                  
      while(first != last)
      {
        m += *first++;
      }
    
      active_viewport()->beep();
    
      m.popup(active_viewport()->window());
    
      return 0;
    }


  }

  return rv;
}


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


int
ViewerManager::
find_files(string operand,
           list<string> *results
          )
{
  FileName tmp(operand);

  if(tmp.is_absolute_path())
  {
    results->push_back(tmp);
    return 1;
  }

  int count = 0;

  // first, find all matching files from the CDPATH
  {
    StrTool::stringlist_t dirs;
    int count = StrTool::parse_words(ProgramOptions::global_options_->getenv("CDPATH"),
                                     &dirs,
                                     1000000,
                                     StrTool::Is_Colon()
                                    );
   
    StrTool::stringlist_t::iterator f, l;
    
    for(f = dirs.begin(), l = dirs.end(); f != l; ++f)
    {
      string const& cur = *f;

      FileName tmp(cur);  
      
      tmp += string("/") + operand;

      if(tmp.exists())
      {
        results->push_back(tmp);
        ++count;
      }

    }
  }  

  // next include all references from the etags database

  {
     CppTagDB::Info* db = default_cpptags_db();

     if(db)
     {
        vector<string> tmp;

        db->findMatchingFiles(operand, tmp);

        for(size_t i = 0; i < tmp.size(); ++i)
        {
           results->push_back(tmp[i]);
           ++count;
        }


     }

  }

  {
    EtagsDB* db = default_etags_db();

    if(db && db->ok())
    {
      count += db->matching_files(operand, results);
    }
  }


  return count;

}

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

};


FileName
ViewerManager::
find_file_in_standard_locations(FileName const &fragment, FileName const &directory)
{
  FileName name;  // return value

  if(fragment.is_absolute_path())
  {
    // no need to search for it.

     return fragment;
  }

  // the directory should include a trailing /

  // search for a given filename fragment in all the standard locations.
  // the standard locations are defined by the algorithm below, but they include
  //
  //    directory + fragment  -- there is a presumed directory but it may not in fact
  //                             be the correct one.
  //
  //    SOURCEPATH as defined by environment variable -- a colon (or semicolon) separated list
  //               (depending on the os) of directories to look for files.
  //
  //    CDPATH     similar to SOURCEPATH but this is obsolete -- please do not use.
  //
  //    TAGPP.tagpp  This is a database of source files generated by cpptagdb.exe.
  //                 The viewermanager keeps track of it and this function will search
  //                 it for files matching the specified fragment.
  //
  //    TAGS         The etags generated source file database.  The viewer manager keeps
  //                 track of it and we will search it here.



  FileName specified_name(fragment);
  FileName local_dir_reference = directory + specified_name;

  local_dir_reference.convert_to_absolute_path();

  if( ! local_dir_reference.exists() )
  {

    std::string cdpath = ProgramOptions::global_options_->getenv("SOURCEPATH");

    if(cdpath.empty())
      cdpath = std::string(ProgramOptions::global_options_->getenv("CDPATH"));

    bool found=false;

    if(!cdpath.empty())
    {
      // re-architect the cdpath variable such that path elements beginning with ./ and ..
      // are prefixed with the name of the directory in which file being edited lies.

      if(directory.size())
      {
        
        StrTool::stringlist_t splitpath;
      
        Is_Path_Separator functor;
      
        StrTool::parse_words(cdpath,
                             &splitpath,
                             2000000000U,
                             functor
                            );
      
        StrTool::stringlist_t::iterator f = splitpath.begin();
        StrTool::stringlist_t::iterator l = splitpath.end();
      
        while(f != l)
        {
          std::string &s = *f++;

          if(s.size() > 2 && s[0] == '.' && ( s[1] == '.' || s[1] == '/' || s[1] == '\\' ))
          {
            s = directory + s;  // assumes trailing slash is found on dirname
          }
        }

        cdpath.resize(0);

        f = splitpath.begin();

        while(f != l)
        {
          if(f != splitpath.begin())
            cdpath += ':';

          cdpath += *f++;
        }

      }


    }

    if(!cdpath.empty())
    {
      FileName cd_path_location( FileName::find_file_in_path(specified_name, cdpath ) );

      if(cd_path_location.size())
      {
        name = cd_path_location;
        specified_name = name;
        found=true;
      }

    }

    if(!found)
    {
      CppTagDB::Info * cpptags=(default_cpptags_db());  // pts to static object

      if(cpptags)
      {
        std::vector<std::string> matches;

        std::string search_name;

        size_t first_good_char = static_cast<std::string const &>(specified_name).find_first_not_of("..\\/");

        if(first_good_char < specified_name.size())
          search_name = specified_name.substr(first_good_char, specified_name.size() - first_good_char);
        else
          search_name = specified_name;
        
        cpptags->findRelativeFiles(search_name, matches);
        
        if(!matches.empty())
        {
          std::string const & s = *matches.begin();
        
          name = s;
          found=true;
          specified_name=name;
        }
      }
    }

    if(!found)
    {
      EtagsDB* etags=(default_etags_db());  // pts to static object

      if(etags && etags->ok())
      {
        std::list<std::string> matches;

        std::string search_name;

        size_t first_good_char = static_cast<std::string const &>(specified_name).find_first_not_of("..\\/");

        if(first_good_char < specified_name.size())
          search_name = specified_name.substr(first_good_char, specified_name.size() - first_good_char);
        else
          search_name = specified_name;
        
        int count = etags->matching_files(search_name, &matches);
        
        if(count)
        {
          std::string const & s = *matches.begin();
        
          name = s;
          found=true;
          specified_name=name;
        }
      }
    }
  }
  else
  {
    specified_name=local_dir_reference;

    name = specified_name;

  }

  return name;

}

void ViewerManager::findMatchingViewers(FileName namePattern, std::list<std::pair<Viewer*, FileName> > &viewers)
{
    CXXTLS_FOREACH(vpentry &cur, viewers_)
    {
        FileName curFile(cur.second);

        if( curFile.matches(namePattern) )
        {
           viewers.push_back(std::pair<Viewer*,FileName>(cur.first, cur.second) );
        }
    }
}



Viewer* ViewerManager::most_recent_viewer()
{
    if(order_.empty())
    {
       if(viewers_.empty())
           return 0;

       return viewers_.back().first;
    }

    // if we get here, there is at least one previously activated viewer.

    MRU<std::string>::iterator mruPtr = order_.mostRecent();

    if(mruPtr != order_.end())
    {
        std::string mru = *mruPtr;
        
        return find_viewer(mru);  // may return null!
    }

    return viewers_.back().first; 


}



} // namespace cxxtls