cursorwindow.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/foreach.h>
#include <cxxtls/cursorwindow.h>
#include <cxxtls/cursesinterface.h>
#include <cxxtls/strtool.h>
#include <cxxtls/file.h>
#include <cxxtls/viewer.h>
#include <portable_io.h>
#include <set>

namespace cxxtls
{

using namespace CursesInterface;

int CursorWindow::normal_att        = CursorWindow::normal;
int CursorWindow::active_title_att  = CursorWindow::reverse_bold;
int CursorWindow::inactive_title_att= CursorWindow::bold_ul;
int CursorWindow::active_mark_att   = CursorWindow::reverse_ul;  // highlight plus mark
int CursorWindow::inactive_mark_att = CursorWindow::bold;        // mark but not highlight
int CursorWindow::bottom_att        = CursorWindow::underlined;  // bottom line of viewport
int CursorWindow::highlighted_att   = CursorWindow::reversed;    // highlight but not mark
int CursorWindow::dialog_normal_att = CursorWindow::reverse_bold;
int CursorWindow::dialog_title_att  = CursorWindow::rev_ul_bold;

typedef CursorWindow::row_col     row_col;
typedef std::string               string;
typedef CursorWindow::viewport    viewport;

const long WScale = 10000;  



                        
const long WHalfCell = (WScale / 2) - 1 ;

struct viewport::port
  //
{
  row_col            scaled_origin_;  // real origin * WScale
  row_col            scaled_size_;    // real size   * WScale
  row_col            curpos_;
  CursorWindow*      window_;
  int                current_attribute_;
  repaint_handler*   handler_;
  viewport::position position_;

  port(CursorWindow* w, viewport::repaint_handler* h, viewport::position p)
  : curpos_(0,0),
    window_(w),
    current_attribute_(CursorWindow::normal),
    handler_(h),
    position_(p)
  {
    scaled_origin_.row_ = 0;  // 0 times 10,000
    scaled_origin_.col_ = 0;  // 0 times 10,000

    scaled_size_.row_ = w->size().row_ * WScale;
    scaled_size_.col_ = w->size().col_ * WScale;

  }

  row_col size()
  {
    row_col rv(scaled_size_);

    rv.row_ /= WScale;
    rv.col_ /= WScale;

    return rv;

  }

  row_col origin()
  {
    row_col rv(scaled_origin_);

    rv.row_ /= WScale;
    rv.col_ /= WScale;

    return rv;

  }

};

#define port            viewport::port
#define repaint_handler viewport::repaint_handler


struct compare_port_by_row_col
{
  bool operator() (port* a, port* b)
  {
    if(a == b)
      return false;

    int a_row = a->scaled_origin_.row_;
    int b_row = b->scaled_origin_.row_;

    if(a_row < b_row)
      return true;

    if(a_row > b_row)
      return false;

    // a and b originate on the same row

    int a_col = a->scaled_origin_.col_;
    int b_col = b->scaled_origin_.col_;

    if(a_col < b_col)
      return true;

    return false;


  }
};

struct compare_port_by_col_row
{
  bool operator() (port* a, port* b)
  {
    if(a == b)
      return false;

    int a_col = a->scaled_origin_.col_;
    int b_col = b->scaled_origin_.col_;

    if(a_col < b_col)
      return true;

    if(a_col > b_col)
      return false;

    // a and b originate on the same col

    int a_row = a->scaled_origin_.row_;
    int b_row = b->scaled_origin_.row_;

    if(a_row < b_row)
      return true;

    return false;

  }
};







class CursorWindow::Window
  //
  //
{
public:

   int                     current_attribute_;
   row_col                 curpos_;
   row_col                 size_;
   char const           *  error_;
   bool                    open_;
   resize_handler  *       resize_handler_;

   port*                   viewport_[100];
   int                     active_viewport_;
   int                     viewports_;
   int                     needs_resized_; 

   Window()      
   : current_attribute_(normal),
     curpos_(0,0),
     size_(0,0),
     error_(0),
     open_(0),
     resize_handler_(0),
     active_viewport_(0),
     viewports_(0),
     needs_resized_(0)
   {

   }

   port* new_port(CursorWindow* w, repaint_handler* h, viewport::position p)
   {
     port* n = new port(w,h,p);

     viewport_[viewports_++] = n;

     return n;

   }

   void cover_hole(port* deceased)
   {
     // 'deceased' must not have been deleted till after this function returns!

     // This algorithm ignores floating viewports!

     // resize other viewports to close the hole left by deleting port p.
     // this function doesn't delete p, it just rescales the remaining ports.
     // The assumption is that p has NOT yet been deleted.
     //
     // Here are the cases of interest:
     //
     //   One viewport being deleted:  (case 1)
     //
     //       +-------------+
     //       |             |      -- no viewports are left
     //       +-------------+
     //
     //   Horizontally split viewport with one being deleted: (case 2)
     //
     //       +------+------+
     //       |      |      |      -- one viewport is left -- it gets the whole
     //       +------+------+         window
     //
     //   Vertically split viewport with one being deleted: (another case 2)
     //
     //       +-------------+
     //       |             |      -- one viewport is left, it gets the whole
     //       +-------------+         screen
     //       |             |
     //       +-------------+
     //
     //   Three splits become two, when viewport X is deleted: (case 3)
     //
     //       +-----+-----+----+
     //       |  Y  |  X  |    |            And the resultant is:
     //       +-----+-----+----+
     //                                 +--------+----+
     //                                 |   Y    |    |
     //                                 +--------+----+
     //
     //   In general with simple splits like the above, one viewport is deleted
     //   and the deleted space goes to another viewport.  Even if there 12
     //   horizontal or vertical splits.  In general, ONE viewport of the remaining
     //   set is given the space vacated by the deleted
     //
     //   Here is a more complex case:  (case 4)
     //
     //       +-----+-----+----+   -- In this case, viewport X is being deleted
     //       |     |  y  |    |      and the space in X given to 'y':
     //       |     +-----+    |
     //       |     |  X  |    |          +------+-------+------+  'resultant'
     //       +-----+-----+----+          |      |       |      |
     //       |                |          |      |   Y   |      |
     //       +----------------+          |      |       |      |
     //                                   +------+-------+------+
     //                                   |                     |
     //                                   +---------------------+
     //
     //  As you can see, an attempt is made to give all the freed space to a
     //  single window if possible.  The receiving viewport must contguous
     //  with and identical in either width or height so that it can exactly
     //  absorb the freed space.
     //
     //  However, this isn't always possible.  Consider, the deletion of D:
     //  (case 5)
     //
     //   +----+----+----+
     //   |    |    |    |      And the resultant is:
     //   +----+----+----+
     //   |       D      |         +----+----+----+
     //   +--------------+         |    |    |    |
     //                            |    |    |    |
     //                            |    |    |    |
     //                            +----+----+----+
     //  In this case, the deleted viewports space is given to ALL windows that
     //  end at the boundary of the deleted viewport.  Here is a more complex
     //  example where Q is being deleted: (case 6)
     //
     //     +----+----+
     //     |    |    |     And the resultant is:
     //     +----+----+
     //     |    Q    |      +-----+-----+
     //     +----+----+      |     |     |
     //     |    |    |      |     |     |
     //     +----+----+      |     |     |
     //                      |     |     |
     //                      +-----+-----+
     //                      |     |     |
     //                      +-----+-----+
     //
     //  In all cases where a viewport's space cannot be given to a single
     //  beneficiary, the dying window will have been one that spans the
     //  either the full width or the full height -- otherwise the viewport
     //  that took up the remainder thereof will be the beneficiary.
     //
     //  The following algorithm handles deletions in the above cases:
     //
     //    Start in the upper left corner viewport
     //
     //    Walk horizontally trying to give space to the viewport to the
     //    left -- or the right if there is no left -- if you can find
     //    a receipient which whose origin in the same row and whose height
     //    is the same. If you find a receipient, give it all the space
     //    and return from the function.  Repeat this for every row on which
     //    a tiled viewport's origin can be found.
     //
     //    If you have gotten to the lower right corner of the screen,
     //    repeat the above algorithm only walk from the upper left corner to
     //    the the lower right in a "column major" order instead of a row major
     //    order.
     //
     //    If you don't escape from the algorithm, it must be because the
     //    deceased port spans the complete width or complete height of the
     //    cursorwindow.  If this is true find all windows to the left or
     //    above, depending and give all the vertical or horizontal space to
     //    the remaining windows.  See cases 5 and 6 above.

     typedef std::set<port*, compare_port_by_row_col> row_major_set_type;
     typedef std::set<port*, compare_port_by_col_row> col_major_set_type;

     row_major_set_type rowset;
     col_major_set_type colset;

     int i;

     for(i=0; i < viewports_; ++i)
     {
        port* p = viewport_[i];
        
        if(p->position_ == viewport::tiled)
        {
          rowset.insert(p);
          colset.insert(p);
        }
        
     }

     // At this point, we two lists of all the 'tiled' windows.  The lists are
     // sorted 1) by the row first then the column -- leading to a row-major
     // iteration scheme, and 2) by the col first and then the row.

     // FIRST: iterate over the row major list and try to give all the freed
     //        space to the row that is the same height, begins in the same
     //        row and is immediately to the left of the deceased.

     row_col origin;
     row_col size;

     origin.row_ = deceased->scaled_origin_.row_ / WScale;
     origin.col_ = deceased->scaled_origin_.col_ / WScale;
     size.row_   = deceased->scaled_size_.row_   / WScale;
     size.col_   = deceased->scaled_size_.col_   / WScale;

     row_major_set_type::iterator rowscan;
     col_major_set_type::iterator colscan;

     for(rowscan = rowset.begin(); rowscan != rowset.end(); ++rowscan)
     {
       port *cur = *rowscan;

       row_col curorg;
       row_col cursiz;

       curorg.row_ = cur->scaled_origin_.row_  / WScale;
       curorg.col_ = cur->scaled_origin_.col_  / WScale;
       cursiz.row_ = cur->scaled_size_.row_    / WScale;
       cursiz.col_ = cur->scaled_size_.col_    / WScale;

       if(curorg.row_ != origin.row_)
         continue;

       if(origin.col_ == 0)
       {
         // give my space to the viewport to the right
        
         if(curorg.col_ == (origin.col_ + size.col_)
            &&
            cursiz.row_ == size.row_
           )
         {
           // the current item begins immediately to the right of the
           // deceased and is the same height -- thus it receives the
           // freed space.
        
           cur->scaled_origin_.col_ = origin.col_ * WScale;
           cur->scaled_size_.col_  += size.col_   * WScale;
        
           return; // yeah baby, YEAH!
        
         }
        
       }
       else
       {
         // give my space to the viewport to the left
        
         if(origin.col_ == (curorg.col_ + cursiz.col_)
            &&
            size.row_ == cursiz.row_
           )
         {
           // the current item ends immediately to the left of the
           // deceased and is the same height -- thus it receives the
           // freed space.
        
           cur->scaled_size_.col_  += size.col_ * WScale;
        
           return; // yeah baby, YEAH!
         }
        
        
       }
     }

     // Ok, if we get here, it means that there is no window of the same
     // height as the deceased that begins on the same row and is strictly
     // contiguous with the deceased.  Now look for a window that occupies
     // exactly the same column as the decedent is contiguous therewith.

     for(colscan = colset.begin(); colscan != colset.end(); ++colscan)
     {
       port *cur = *colscan;

       row_col curorg;
       row_col cursiz;

       curorg.row_ = cur->scaled_origin_.row_  / WScale;
       curorg.col_ = cur->scaled_origin_.col_  / WScale;
       cursiz.row_ = cur->scaled_size_.row_    / WScale;
       cursiz.col_ = cur->scaled_size_.col_    / WScale;

       if(curorg.col_ != origin.col_)
         continue;

       if(origin.row_ == 0)
       {
         // give my space to the viewport below
        
         if(curorg.row_ == (origin.row_ + size.row_)
            &&
            cursiz.col_ == size.col_
           )
         {
           // the current item begins immediately to the right of the
           // deceased and is the same height -- thus it receives the
           // freed space.
        
           cur->scaled_origin_.row_ = origin.row_ * WScale;
           cur->scaled_size_.row_  += size.row_   * WScale;
        
           return; // yeah baby, YEAH!
        
         }
        
       }
       else
       {
         // give my space to the viewport above
        
         if(origin.row_ == (curorg.row_ + cursiz.row_)
            &&
            size.col_ == cursiz.col_
           )
         {
           // the current item ends immediately to the left of the
           // deceased and is the same height -- thus it receives the
           // freed space.
        
           cur->scaled_size_.row_  += size.row_  * WScale;
        
           return; // yeah baby, YEAH!
         }
        
        
       }
     }

     // OK, at this point, we have no best match to receive the freed
     // space -- so try to handle the case where the decedent is either
     // exactly as wide or exactly as tall as the cursor window.

     for(rowscan = rowset.begin(); rowscan != rowset.end(); ++rowscan)
     {
       //
       // This could just as easily have been colscan instead of rowscan
       // because the algorithm below isn't interested in rowmajor or
       // column majorprocessing.
       //

       port *cur = *rowscan;

       row_col curorg;
       row_col cursiz;

       curorg.row_ = cur->scaled_origin_.row_  / WScale;
       curorg.col_ = cur->scaled_origin_.col_  / WScale;
       cursiz.row_ = cur->scaled_size_.row_    / WScale;
       cursiz.col_ = cur->scaled_size_.col_    / WScale;

       if(size_.row_ == size.row_)
       {
         // the decedent occupies an entire column
        
         if(origin.col_ == 0)
         {
           // widen viewports at the right to occupy the missing space
        
           if(curorg.col_ == size.col_)
           {
             cur->scaled_origin_.col_ = 0;
             cur->scaled_size_.col_  += WScale * size.col_;
           }
        
         }
         else
         {
           // widen viewports to the left to occupy the missing space
        
           if(curorg.col_ + cursiz.col_ == origin.col_)
           {
             cur->scaled_size_.col_ += WScale * size.col_;
           }
        
         }
       }
       else
       if(size_.col_ == size.col_)
       {
         if(origin.row_ == 0)
         {
           // widen viewports below to occupy the missing space
        
           if(curorg.row_ == size.row_)
           {
             cur->scaled_origin_.row_ = 0;
             cur->scaled_size_.row_  += WScale * size.row_;
           }
        
         }
         else
         {
           // widen viewports above to occupy the missing space
        
           if(curorg.row_ + cursiz.row_ == origin.row_)
           {
             cur->scaled_size_.row_ += WScale * size.row_;
           }
        
         }
       }
       else
       {
         // the decedent does not consume an entire row or column
         // so we are in a case like this:
         //
         //   +---------+
         //   |    T    |   When viewport, DD, is deleted, its
         //   +----+----+   space must be given to A and B.
         //   | A  |    |
         //   +----+ DD |
         //   | B  |    |
         //   +----+----+
         //
         // As you can see, the reason A and B get space but not T
         // is that the height of A and B are totally within the range
         // of DD, where T's width only partially overlaps DD.  Further
         // A begins on a row common to DD and B ends on such a row.
         //
         // Thus, the rules for giving space to a viewport is this:
         //
         // The candidate must share a common edge with the decedent
         // and candidate must not be wider or taller than the decdent
         // and the decedent.  More than one candidate can get space.
         //
         //
        
         if( ( (curorg.row_ == origin.row_)                   ||
               (curorg.row_ + cursiz.row_) == (origin.row_ + size.row_)
             )
             &&
             (
               (curorg.col_ + cursiz.col_) == origin.col_  ||
               (origin.col_ + size.col_)   == curorg.col_
             )
             &&
             (
               (curorg.row_ >= origin.row_) &&
               (curorg.row_ +  cursiz.row_) <= (origin.row_ + size.row_)
             )
           )
         {
             // give width to 'cur'
        
             if(curorg.col_ == origin.col_ + size.col_)
             {
               // widen to the left
        
               cur->scaled_origin_.col_ = origin.col_ * WScale;
               cur->scaled_size_.col_  += size.col_   * WScale;
        
             }
             else
             {
               cur->scaled_size_.col_ += size.col_ * WScale;
             }
        
         }
         else
         if( ( (curorg.col_ == origin.col_)                   ||
               (curorg.col_ + cursiz.col_) == (origin.col_ + size.col_)
             )
             &&
             (
               (curorg.row_ + cursiz.row_) == origin.row_  ||
               (origin.row_ + size.row_)   == curorg.row_
             )
             &&
             (
               (curorg.col_ >= origin.col_) &&
               (curorg.col_ +  cursiz.col_) <= (origin.col_ + size.col_)
             )
           )
         {
             // give height to 'cur'
        
             if(curorg.col_ == origin.col_ + size.col_)
             {
               // widen to the top
        
               cur->scaled_origin_.row_ = origin.row_ * WScale;
               cur->scaled_size_.row_  += size.row_   * WScale;
        
             }
             else
             {
               cur->scaled_size_.row_ += size.row_ * WScale;
             }
         }
        
       }
     }

     // hopefully we caught it!

   }

   void delete_port(port* p)
   {
     int i;

     needs_resized_ = true;

     cover_hole(p);

     for(i=0; i < viewports_; ++i)
     {
       if(viewport_[i] == p)
       {

         // remove this port from the list and delete it.
        
         delete p;
        
         while(i < viewports_)
         {
           viewport_[i] = viewport_[i+1];
           ++i;
         }
        
         --viewports_;
        
         active_viewport_ = viewports_-1;
        
         if(viewports_)
         {
           viewport a(viewport_[active_viewport_]);

           port*            active_port = viewport_[active_viewport_];
           repaint_handler* rh          = active_port->handler_;
                
           (*rh)(&a, repaint_handler::activate);
        
         }
        
         return;
        
       }
     }
   }

   void repaint_ports()
   {
     int i;

     int resize_cmd = repaint_handler::resize;

     for(i=0; i < viewports_; ++i)
     {
       if( i != active_viewport_ )
       {
         port* p = viewport_[i];
        
         viewport v(p);
        
         (*p->handler_)(&v, resize_cmd);
        
       }
     }

     if(i)
     {
       port* a = viewport_[active_viewport_];

       viewport v(a);

       (*a->handler_)(&v, resize_cmd);

     }

   }

   void activate(viewport* p)
   {
      if(viewports_ && active_viewport_ >= 0)
      {
        port* a = viewport_[active_viewport_];

        viewport v(a);

        (*a->handler_)(&v, repaint_handler::deactivate);
      }

      int i;

      for(i=0; i < viewports_; ++i)
      {
        if(viewport_[i] == p->port_)
        {
          active_viewport_ = i;
          (*p->port_->handler_)(p, repaint_handler::activate);
          break;
        }
      }

   }




   void resize_viewports(
                         row_col const &old_size,
                         row_col const &new_size
                        )
   {
     long scaled_row = new_size.row_ * WScale;
     long scaled_col = new_size.col_ * WScale;


     for(int i = 0; i < viewports_; ++i)
     {
       port* p = viewport_[i];
        
       long tmp;

       // Before rescaling, see if this window was aligned with the right side
       // of the window.  If it was, make sure it still is after the scaling.
       // Same goes for the bottom.

       int  right_side     = (p->scaled_origin_.col_ + p->scaled_size_.col_) / WScale;
       bool right_aligned  = right_side >= old_size.col_;

       int  bottom_side    = (p->scaled_origin_.row_ + p->scaled_size_.row_) / WScale;
       bool bottom_aligned = bottom_side >= old_size.row_;


       // handle origin

       tmp   = p->scaled_origin_.row_;
       tmp  *= new_size.row_;
       tmp  /= old_size.row_;

       if(tmp > scaled_row)
       {
         tmp = scaled_row;
       }

       p->scaled_origin_.row_ = tmp;

       tmp   = p->scaled_origin_.col_;
       tmp  *= new_size.col_;
       tmp  /= old_size.col_;

       if(tmp > scaled_col)
       {
         tmp = scaled_col;
       }
       p->scaled_origin_.col_ = tmp;


       // handle size

       tmp   = p->scaled_size_.row_;
       tmp  *= new_size.row_;
       tmp  /= old_size.row_;

       if(tmp + p->scaled_origin_.row_ > scaled_row)
       {
         tmp = scaled_row - p->scaled_origin_.row_;
       }
       p->scaled_size_.row_ = tmp;

       tmp   = p->scaled_size_.col_;
       tmp  *= new_size.col_;
       tmp  /= old_size.col_;

       if(tmp + p->scaled_origin_.col_ > scaled_col)
       {
         tmp = scaled_col - p->scaled_origin_.col_;
       }
       p->scaled_size_.col_ = tmp;


       // handle curpos
       tmp   = p->curpos_.row_ * WScale;
       tmp  *= new_size.row_;
       tmp  /= old_size.row_;
       p->curpos_.row_ = tmp / WScale;

       tmp   = p->curpos_.col_ * WScale;
       tmp  *= new_size.col_;
       tmp  /= old_size.col_;
       p->curpos_.col_ = tmp / WScale;
        

       // handle right and bottom aligned viewports

       if(p->position_ == viewport::floating)
       {
         //
         // if we are dealing with a floating window, don't force it to align up
         // to the right or bottom -- or to tile nicely with is friends
         //
        
         continue;
        
       }

       if(right_aligned)
       {
         int origin_col = p->scaled_origin_.col_ / WScale;
        
         int real_width = new_size.col_ - origin_col;
        
         p->scaled_size_.col_ = real_width * WScale;
       }
                                
       if(bottom_aligned)
       {
         int origin_row = p->scaled_origin_.row_ / WScale;
        
         int real_height = new_size.row_ - origin_row;
        
         p->scaled_size_.row_ = real_height * WScale;
        
       }

     }

   }

};

static bool key_map_initialized = false;


std::map<int,int> CursorWindow::func;

string CursorWindow::word;

CursorWindow::
CursorWindow()
{
  window_ = new CursorWindow::Window;

  if(!key_map_initialized)
  {
    key_map_initialized = true;

    func[key_up   ] = func_up;
    func[key_down ] = func_down;
    func[key_left ] = func_left;
    func[key_right] = func_right;
    func[key_dc   ] = func_dc;      // delete character
    func[key_bs   ] = func_dc_prev; // delete previous character (1 to the left)
    #ifdef _MSC_VER
    func[0x08     ] = func_dc_prev; // ^H too on dos delete previous character (1 to the left)

    #endif


    func[key_home ] = func_home;
    func[0x01     ] = func_home;    // ^A
    func[key_end  ] = func_end;
    func[0x05     ] = func_end;     // ^E
    func[key_prior] = func_prior;
    func[0x0f     ] = func_prior;   // ^O
    func[key_next ] = func_next;
    func[0x04     ] = func_next;    // ^D
    func[0x09     ] = func_tab;
    func[key_btab ] = func_btab;
    func[0x14     ] = func_top;     // ^T
    func[0x02     ] = func_bottom;  // ^B
    func[0x1b     ] = func_esc;
    func[0x03     ] = func_esc;     // ^C
    func['\r'     ] = func_enter;   // Enter Key
    func[0x0b     ] = func_clreol;  // ^K
    func[0x17     ] = func_nextwd;  // ^W
    func[0x11     ] = func_prevwd;  // ^Q
    func[0x15     ] = func_upword;  // ^U
    func[0x0c     ] = func_dnword;  // ^L
    func[0x1f     ] = func_undo;    // ^_  (ctrl shift underscore OR ^/)
    func[0x12     ] = func_repl;    // ^R
    func[0x19     ] = func_replnext;// ^Y
    func[0x13     ] = func_find;    // ^S
    func[0x0e     ] = func_findnxt; // ^N
    func[0x10     ] = func_findprv; // ^P
    func[key_f1   ] = func_help;    // F1
    func[key_f3   ] = func_db;      // F3  cut block to paste buffer
    func[key_f5   ] = func_mark;    // F5
    func[key_f6   ] = func_clreol;  // F6
    func[key_f7   ] = func_paste;   // F7  insert the paste buffer above current line
    func[key_ic   ] = func_paste;   // Insert key has no other reasonable use
                                    // since most keyboard input is in the insert
                                    // mode by default
    func[key_f8   ] = func_dl;      // F8 (delete line)
    func[key_f11  ] = func_cb;      // F11 copy block to paste buffer
    func[0x07     ] = func_goto;    // ^G -- goto line
    func[0x1c     ] = func_matching;// ^\  (ctrl backslash)
    func[0x03     ] = func_dw;      // delete word
    func[key_f4   ] = func_join;    // F4  join lines
    func[key_f9   ] = func_insline; // F9  insert blank line
    func[0x1a     ] = func_to_edit; // ^Z  convert view session to edit
    func[key_f12  ] = func_switch;  // F12 switch to alternate source file

    int i;

    for(i=' '; i < 0x7f; ++i)
      func[i] = func_data;

    for(i='a'; i <= 'z'; ++i)
      word += char(i);

    for(i='A'; i <= 'Z'; ++i)
      word += char(i);

    word += '_';
    word += '$';


  }

}

string CursorWindow::func_name(int fun)
{
  switch(fun)
  {
    case func_up:      return "CUR_UP_1_LN";
    case func_down:    return "CUR_DN_1_LN";
    case func_left:    return "CUR_LF_1_CH";
    case func_right:   return "CUR_RT_1_CH";
    case func_ic:      return "~INSMODE";   // toggle insert mode -- not implemented
    case func_dc:      return "DEL_1_CH";
    case func_home:    return "HOME_LINE";
    case func_end:     return "END_LINE";
    case func_prior:   return "PREV_PAGE";
    case func_next:    return "NEXT_PAGE";
    case func_dc_prev: return "DEL_PRV_CH";
    case func_tab:     return "TAB_RIGHT";
    case func_btab:    return "TAB_LEFT";
    case func_top:     return "TOP";
    case func_bottom:  return "BOTTOM";
    case func_esc:     return "ESCAPE";
    case func_enter:   return "ENTER";
    case func_data:    return "DATA";
    case func_clreol:  return "CLR_2_EOL";
    case func_nextwd:  return "NXT_WD";
    case func_prevwd:  return "PRV_WD";
    case func_upword:  return "UPCASE_WD";
    case func_dnword:  return "DNCASE_WD";
    case func_undo:    return "UNDO";
    case func_find:    return "FIND";
    case func_findnxt: return "FIND_NEXT";
    case func_findprv: return "FIND_PREV";
    case func_repl:    return "REPLACE";
    case func_replnext:return "REPLACE_NXT";
    case func_help:    return "HELP";
    case func_mark:    return "MARK (block)";
    case func_dl:      return "DEL_1_LINE";
    case func_dw:      return "DEL_WORD";
    case func_db:      return "DEL_BLOCK";
    case func_cb:      return "COPY_BLOCK";
    case func_paste:   return "PASTE (block)";
    case func_join:    return "JOIN (lines)";
    case func_insline: return "INSERT_BLANK_LINE";
    case func_to_edit: return "CONV VIEW TO EDIT";
    case func_reread:  return "RE_READ_FILE"; 
  };

  return "USER_FUNC";

}




CursorWindow::
~CursorWindow()
{
  if(window_->open_)
    close();

  delete window_;

  window_ = 0;

}

void
CursorWindow::
close()
{
  closeCursesTerminal();
  window_->open_ = false;
}


bool
CursorWindow::
open()
{
  if(!window_->open_)
  {
    openCursesTerminal();

    window_->open_ = true;

    getCursesScreenSize(&window_->size_.row_,&window_->size_.col_);

  }

  return false;
}

char const *
CursorWindow::
error() const
{
  return window_->error_;
}

void
CursorWindow::
set_error(char const *s)
{
  window_->error_ = s;
}


void
CursorWindow::
needs_resized()
{
   window_->needs_resized_ = true;
   resize_requested = 1;
}


void
CursorWindow::
refresh()
{
  if(window_->needs_resized_)
  {
    window_->needs_resized_ = 0;
    resize_requested        = 0;

    if(window_->resize_handler_)
      (*window_->resize_handler_)(this);

    window_->repaint_ports();

  }
  refreshCursesWindow();
}



CursorWindow::input_event
CursorWindow::
read_input()
{

  int key;

  //
  // read events and handle resizes by either calling the window's resize
  // handler or by returning a resize event.
  //

  refresh();


  for(;;)
  {

    key = CursesInterface::read_mapped_key(*this);

    if(key == CursesInterface::ResizeEvent)
    {
      winch_occurred   = 0;  // officially handling winch
      resize_requested = 0;

      row_col old_size = window_->size_;

      getCursesScreenSize(&window_->size_.row_,
                          &window_->size_.col_
                         );
                        
      row_col new_size = window_->size_;

      if(window_->resize_handler_)
      {
        (*window_->resize_handler_)(this);

        window_->repaint_ports();

        winch_occurred   = 0;  // officially handling winch
        resize_requested = 0;

        continue;
      }

      // no resize handler is specified -- so use a default
      // behavior -- but what?

      // The default resize handler re-scales the viewports
      // in the window to fit in the available space.
        
      window_->resize_viewports(old_size, new_size);

      window_->repaint_ports();

      winch_occurred   = 0;  // officially handling winch
      resize_requested = 0;

      return input_event(input_event::ResizeKey, 0);

    }
    else
    if(key == CursesInterface::MouseEvent)
    {
#ifdef _MSC_VER
      CursesInterface::mouse_info loc = CursesInterface::read_mouse_info();

      int buttonCode = '@' + loc.state_;

#if 0
      row_col org = origin();
#else
      row_col org(0,0); // stubbed out till implemented
#endif

      return input_event(input_event::MouseEvent, buttonCode, loc.row_ - org.row_, loc.col_ - org.col_);
#endif
    }
    else
      break;
  }


  // at this point, we know we have a normal key event


  std::map<int,int>::iterator key_table_loc = func.find(key);

  if(key_table_loc == func.end() ||
     key_table_loc->second == CursorWindow::func_data
    )
  {
    return input_event(input_event::DataKey, key);  // its not a function key
  }


  return input_event(input_event::FunctionKey, key );

}

row_col
CursorWindow::
curpos() const
{
   row_col rc;

   getCursesCursor(&rc.row_, &rc.col_);

   return rc;
}

void
CursorWindow::
set_curpos(row_col rc)
{
  moveCursesCursor(rc.row_, rc.col_);
}

row_col
CursorWindow::
size() const
{
  return window_->size_;
}

void
CursorWindow::
beep()
{
  beepCursesTerminal();
}

void
CursorWindow::
write(char const *s, size_t length)
      //
{
  row_col where = curpos();

  if(where.row_ < 0                    ||
     where.row_ >= window_->size_.row_ ||
     where.col_ >= window_->size_.col_
    )
    return;  // off screen, top, bottom, or right

  if(where.col_ < 0)
  {
    int t = -where.col_ ;

    if(t >= (int)length)
    {
      return ;  // off screen to the left
    }

    // overlaps the screen

    s += t;  // skip parts of string to the left of the screen

    length -= t;  // reduce the length of the drawn string to be the visible
                  // parts

    where.col_ = 0; // and of course start at the left edge

  }

  paintCharString(s, length,  window_->current_attribute_, where.row_, where.col_);

}

void
CursorWindow::
write(long c, int length)
      //
{
  row_col where = curpos();

  if(where.row_ < 0                    ||
     where.row_ >= window_->size_.row_ ||
     where.col_ >= window_->size_.col_
    )
    return;  // off screen, top, bottom, or right

  if(where.col_ < 0)
  {
    int t = -where.col_ ;

    if(t >= (int)length)
    {
      return ;  // off screen to the left
    }

    // overlaps the screen

    length -= t;  // reduce the length of the drawn string to be the visible
                  // parts

    where.col_ = 0; // and of course start at the left edge

  }

  paintCharString(c, length,  window_->current_attribute_, where.row_, where.col_);

}


void
CursorWindow::
fill_to_eol(char c)
{
  int remaining_length = size().col_ - curpos().col_;

  write(c, remaining_length);

}

void
CursorWindow::
fill_to_eos(char c)
{
   int i;

   row_col where = curpos();

   int rows = size().row_;

   fill_to_eol(c);

   for(i = where.row_+1; i < rows; ++i)
   {
     set_curpos(i, 0);
     fill_to_eol(c);
   }


}

void
CursorWindow::
box(int width, int height, bool filled, char const *string, unsigned length)
{
   using namespace CursesInterface;

   row_col where = curpos();
   row_col dims  = size();

   int row = where.row_;
   int col = where.col_;

   if(width + where.col_ >= dims.col_)
   {
     // truncate to end of screen

     width = dims.col_ - where.col_;

     if(width < 1)
       return;  

   }

   int count=0;

   long horz = line_chars[HL_MIDDLE];
   long fill = line_chars[HL_MIDDLE];
   long tl   = line_chars[UL_CORNER];
   long bl   = line_chars[LL_CORNER];
   long tr   = line_chars[UR_CORNER];
   long br   = line_chars[LR_CORNER];
   long bar  = line_chars[VL_MIDDLE];
   
   while(row < dims.row_ && count < height)
   {
     // paint each row but don't run off the screen

     row_col here(row,col);

     if(filled)
     {
       set_curpos( here );

       if(count == height-1)
         fill = horz;

       for(int i = col; i < col + width; ++i)
         write(fill, 1);

       fill = ' ';
     }


     if(count == 0)
     {
       set_curpos( here );
       write(tl, 1);
       set_curpos( row_col(row, col + width-1));
       write(tr, 1);
     }
     else
     if(count == height-1)
     {
       set_curpos( here );
       write(bl, 1);
       set_curpos( row_col(row, col + width-1));
       write(br, 1);
     }
     else
     {
       set_curpos( here );
       write(bar, 1);
       set_curpos( row_col(row, col + width-1));
       write(bar, 1);
     }

     ++row;
     ++count;
   }


   if(string)
   {
     set_curpos( row_col( where.row_, where.col_ + 2 ) );

     write(string, length);
     
   }


}

int
CursorWindow::
text_attribute() const
{
  return window_->current_attribute_;
}

void
CursorWindow::
set_text_attribute(int a)
{
  window_->current_attribute_ = a;
}


string
CursorWindow::
key_name(int curses_key)
{
  switch(curses_key)
  {
    case CursorWindow::key_up:      return "key_up";
    case CursorWindow::key_down:    return "key_down";
    case CursorWindow::key_left:    return "key_left";
    case CursorWindow::key_right:   return "key_right";
    case CursorWindow::key_sleft:   return "key_sleft";
    case CursorWindow::key_sright:  return "key_sright";
    case CursorWindow::key_prior:   return "key_prior";
    case CursorWindow::key_next:    return "key_next";
    case CursorWindow::key_ic:      return "key_ic";
    case CursorWindow::key_dc:      return "key_dc";
    case CursorWindow::key_bs:      return "key_bs";
    case CursorWindow::key_home:    return "key_home";
    case CursorWindow::key_end:     return "key_end";
    case CursorWindow::key_btab:    return "key_btab";

    case CursorWindow::key_f1:   return "key_f1";
    case CursorWindow::key_f2:   return "key_f2";
    case CursorWindow::key_f3:   return "key_f3";
    case CursorWindow::key_f4:   return "key_f4";
    case CursorWindow::key_f5:   return "key_f5";
    case CursorWindow::key_f6:   return "key_f6";
    case CursorWindow::key_f7:   return "key_f7";
    case CursorWindow::key_f8:   return "key_f8";
    case CursorWindow::key_f9:   return "key_f9";
    case CursorWindow::key_f10:   return "key_f10";
    case CursorWindow::key_f11:   return "key_f11";
    case CursorWindow::key_f12:   return "key_f12";
    case 0x1b:                    return "key_esc";
    case 0x1c:                    return "^\\";
    case 0x1f:                    return "^/ or ^_";
  }

  char buffer[40];

  if(curses_key >= ' ' && curses_key <= 0x7e)
    sprintf(buffer, "'%c'", curses_key);
  else
    sprintf(buffer, "^%c", '@' + curses_key);


  return buffer;

}

void
CursorWindow::set_resize_handler( CursorWindow::resize_handler *h )
{
  window_->resize_handler_ = h;
}

void
viewport::
beep()
{
  window()->beep();
}


viewport::
viewport(CursorWindow* w, repaint_handler* r, viewport::position p)
{
  port_ = w->window_->new_port(w,r,p);
  owned_ = true;
}

viewport::
viewport(port* p)
{
  port_ = p;
  owned_ = false;
}


viewport::
~viewport()
{
  if(owned_)
    port_->window_->window_->delete_port(port_);

  port_ = 0;
}


void
viewport::
write(char const *s, size_t length)
      //
{
  row_col where = curpos();
  row_col vsize  = size();

  if(where.row_ < 0                  ||
     where.row_ >= port_->size().row_ ||
     where.col_ >= port_->size().col_
    )
    return;  // off screen, top, bottom, or right

  if(where.col_ < 0)
  {
    int t = -where.col_ ;

    if(t >= (int)length)
    {
      return ;  // off screen to the left
    }

    // overlaps the screen

    s += t;  // skip parts of string to the left of the screen

    length -= t;  // reduce the length of the drawn string to be the visible
                  // parts

    where.col_ = 0; // and of course start at the left edge

  }

  port_->window_->set_text_attribute(port_->current_attribute_);


  port_->window_->set_curpos(where.row_ + port_->origin().row_,
                             where.col_ + port_->origin().col_);


  if(where.col_ + length > size_t(vsize.col_) )
  {
      length = vsize.col_ - where.col_;
  }

  port_->window_->write(s, length);

  port_->curpos_.col_ += length;

}

void
viewport::
write(long c, int length)
      //
{
  row_col where = curpos();

  if(where.row_ < 0                  ||
     where.row_ >= port_->size().row_ ||
     where.col_ >= port_->size().col_
    )
    return;  // off screen, top, bottom, or right

  if(where.col_ < 0)
  {
    int t = -where.col_ ;

    if(t >= (int)length)
    {
      return ;  // off screen to the left
    }

    // overlaps the screen

    length -= t;  // reduce the length of the drawn string to be the visible
                  // parts

    where.col_ = 0; // and of course start at the left edge

  }

  port_->window_->set_text_attribute(port_->current_attribute_);

  port_->window_->set_curpos(where.row_ + port_->origin().row_,
                             where.col_ + port_->origin().col_);

  port_->window_->write(c, length);

  port_->curpos_.col_ += length;

}


void
viewport::
fill_to_eol(char c)
{
  int remaining_length = size().col_ - curpos().col_;

  write(c, remaining_length);

}

void
viewport::
fill_to_eos(char c)
{
  int i;

  fill_to_eol(c);

  for(i=curpos().row_ + 1; i < size().row_; ++i)
  {
    set_curpos(i, 0);
    fill_to_eol(c);
  }


}

void
viewport::
box(int width, int height, bool filled, char const *string, unsigned length)
{
   row_col where = curpos();
   row_col dims  = size();

   int row = where.row_;
   int col = where.col_;

   if(width + where.col_ >= dims.col_)
   {
     // truncate to end of screen

     width = dims.col_ - where.col_;

     if(width < 1)
       return;  

   }

   int count=0;


   long horz = line_chars[HL_MIDDLE];
   long fill = line_chars[HL_MIDDLE];
   long tl   = line_chars[UL_CORNER];
   long bl   = line_chars[LL_CORNER];
   long tr   = line_chars[UR_CORNER];
   long br   = line_chars[LR_CORNER];
   long bar  = line_chars[VL_MIDDLE];
   
   while(row < dims.row_ && count < height)
   {
     // paint each row but don't run off the screen

     row_col here(row,col);

     if(filled)
     {
       set_curpos( here );

       if(count == height-1)
         fill = horz;

       for(int i = col; i < col + width; ++i)
         write(fill, 1);

       fill = ' ';
     }


     if(count == 0)
     {
       set_curpos( here );
       write(tl, 1);
       set_curpos( row_col(row, col + width-1));
       write(tr, 1);
     }
     else
     if(count == height-1)
     {
       set_curpos( here );
       write(bl, 1);
       set_curpos( row_col(row, col + width-1));
       write(br, 1);
     }
     else
     {
       set_curpos( here );
       write(bar, 1);
       set_curpos( row_col(row, col + width-1));
       write(bar, 1);
     }

     ++row;
     ++count;
   }


   if(string)
   {
     set_curpos( row_col( where.row_, where.col_ + 2 ) );

     write(string, length);
     
   }


}


row_col
viewport::
curpos() const
{
  return port_->curpos_;
}

void
viewport::
set_curpos(row_col rc)
{
  port_->curpos_ = rc;

  rc.row_ += port_->origin().row_;
  rc.col_ += port_->origin().col_;


  port_->window_->set_curpos(rc);
}

void
viewport::
restore_curpos()
{
  set_curpos(port_->curpos_);
}


int
viewport::
text_attribute() const
{
  return port_->current_attribute_;
}

void
viewport::
set_text_attribute(int a)
{
  port_->current_attribute_ = a;
}

std::auto_ptr<viewport>
CursorWindow::new_viewport(repaint_handler* h, viewport::position p)
{
  return std::auto_ptr<viewport>(new viewport(this,h,p));
}


row_col
viewport::
size() const
{
  row_col rv;

  rv.row_ = port_->scaled_size_.row_ / WScale;
  rv.col_ = port_->scaled_size_.col_ / WScale;

  return rv;
}

row_col
viewport::
origin() const
{
  row_col rv;

  rv.row_ = port_->scaled_origin_.row_ / WScale;
  rv.col_ = port_->scaled_origin_.col_ / WScale;

  return rv;

}


void
viewport::
move( row_col origin,
      row_col size
    )
{
  row_col port_origin;

    port_origin.row_ = port_->scaled_origin_.row_ / WScale;
    port_origin.col_ = port_->scaled_origin_.col_ / WScale;

  row_col port_size;

    port_size.row_ = port_->scaled_size_.row_ / WScale;
    port_size.col_ = port_->scaled_size_.col_ / WScale;

  if(origin == port_origin && size == port_size)
    return;


  port_->scaled_origin_.row_ = origin.row_ * WScale + WHalfCell;
  port_->scaled_origin_.col_ = origin.col_ * WScale + WHalfCell;

  port_->scaled_size_.row_ = size.row_ * WScale + WHalfCell;
  port_->scaled_size_.col_ = size.col_ * WScale + WHalfCell;

  port_->window_->needs_resized();

}

void
viewport::
activate()
{
  port_->window_->window_->activate(this);
}

void
viewport::
refresh()
{
  port_->window_->refresh();
}

CursorWindow*
viewport::
window()
{
  return port_->window_;
}



CursorWindow::resize_handler::
~resize_handler()
{
}

#undef repaint_handler

viewport::repaint_handler::
~repaint_handler()
{
}

void
CursorWindow::Dialog::Ok::
handle_key(viewport *v, int key)
{
  v->beep();
}


class CursorWindow::Dialog::Impl
  //
{
public:

  typedef CursorWindow::Dialog::element_list_t  element_list_t;
  typedef element_list_t::iterator              iterator;

  string title_;

  element_list_t  elements_;

  std::string curdir_;

  std::string first_input_field_;

  iterator find_element(string const &name);


  struct visible_page
    //
  {
    iterator page_top_;      
    iterator page_bottom_;   
    iterator current_line_;  
    int      height_;        
    iterator last_line_;     

    int page_offset(iterator line)
      //
      // offset from top of displayed page to the current line
      // (expressed in input fields, starting with 0)
      //
    {
      iterator scan = page_top_;

      int rv = 0;

      while(scan != line && scan != last_line_)
      {
        ++rv;
        ++scan;
      }


      return rv;
    }

    int page_offset()
    {
      return page_offset(current_line_);
    }


  };

  visible_page page_;    

  int desired_width_;    
  int desired_height_;   
  int actual_width_;     
  int actual_height_;    
  int gutter_width_;     
  int first_input_row_;  
  int title_row_;        
  int title_col_;        
  int label_indent_;     

  int desired_label_width_;
  int desired_input_width_;
  int desired_input_column_;     
  int actual_input_column_;

  void draw_current_input_area(viewport *v, bool highlighted)
  {

    int row = page_.page_offset();

    v->set_curpos(row + first_input_row_,
                 actual_input_column_
                );
                
    CursorWindow::Dialog::Element* e = *page_.current_line_;

    e->draw_input_area(v, highlighted);

  }

  void recompute_page_info(viewport* v)
  {
    row_col available = v->window()->size();

    actual_input_column_ = desired_input_column_;

    int trim = desired_width_ - available.col_;

    if(trim >= 1)
    {
      // dialog is too wide -- reduce both labels and input areas

      actual_input_column_ -= trim;

      actual_width_ = available.col_;

    }
    else
      actual_width_ = desired_width_;

    if(desired_height_ > available.row_)
      actual_height_ = available.row_;
    else
      actual_height_ = desired_height_;

    int input_row;

    int max_input_rows = actual_height_ - first_input_row_;

    for(input_row = 0, page_.page_bottom_ = page_.page_top_;
        input_row < max_input_rows && page_.page_bottom_ != page_.last_line_;
        ++input_row, ++page_.page_bottom_
       );


    page_.height_ = input_row;


    row_col upper_left( (available.row_ - actual_height_)/2,
                                      (available.col_ - actual_width_)/2
                                    );


    v->move(upper_left, row_col(actual_height_,actual_width_));

  }


};


void
CursorWindow::Dialog::
set_first_input_field(std::string const &field_name)
{
  impl_->first_input_field_ = field_name;
}


void dumpimpl(CursorWindow::Dialog::Impl *impl_)
{
  //
  // This is a debug helper only, it is pointless to print the stuff for
  // any other reason.
  //

  string beg="\r";

  string label = (*impl_->page_.page_bottom_)->label_;


  std::cout << "desired width       = " << impl_->desired_width_        << beg << std::endl;
  std::cout << "desired height      = " << impl_->desired_height_       << beg << std::endl;
  std::cout << "actual_width        = " << impl_->actual_width_         << beg << std::endl;
  std::cout << "actual_height       = " << impl_->actual_height_        << beg << std::endl;
  std::cout << "gutterwidth         = " << impl_->gutter_width_         << beg << std::endl;
  std::cout << "first_input_row     = " << impl_->first_input_row_      << beg << std::endl;
  std::cout << "title row           = " << impl_->title_row_            << beg << std::endl;
  std::cout << "title col           = " << impl_->title_col_            << beg << std::endl;
  std::cout << "label indent        = " << impl_->label_indent_         << beg << std::endl;
  std::cout << "desired label width = " << impl_->desired_label_width_  << beg << std::endl;
  std::cout << "desired input widht = " << impl_->desired_input_width_  << beg << std::endl;
  std::cout << "desired input col   = " << impl_->desired_input_column_ << beg << std::endl;
  std::cout << "actual input col    = " << impl_->actual_input_column_  << beg << std::endl;
  std::cout << "page_bottom_        = " << label                        << beg << std::endl;
  std::cout << std::flush;
}

CursorWindow::Dialog::
Dialog(string title)
{
  impl_ = new CursorWindow::Dialog::Impl;
  impl_->title_ = title;

  impl_->gutter_width_    = 2;  // ": "
  impl_->first_input_row_ = 1;  // first row under title
  impl_->title_row_       = 0;  // top of dialog
  impl_->title_col_       = 0;  // offset from left side to title
  impl_->label_indent_    = 2;  // from left side of dialog to labels

  // safe initializations

  impl_->desired_width_        = 0;
  impl_->desired_height_       = 0;
  impl_->actual_width_         = 0;
  impl_->actual_height_        = 0;
  impl_->desired_input_column_ = 0;
  impl_->actual_input_column_  = 0;
  impl_->desired_label_width_  = 0;
  impl_->desired_input_width_  = 0;

  impl_->page_.page_top_       = end();
  impl_->page_.page_bottom_    = end();
  impl_->page_.current_line_   = end();
  impl_->page_.height_         = 0;
  impl_->page_.last_line_      = end();


}

CursorWindow::Dialog::
~Dialog()
{
  for(iterator f = begin(), l = end(); f != l; ++f)
  {
    delete *f;
  }

  delete impl_;

  impl_ = 0;
}

CursorWindow::Dialog&
CursorWindow::Dialog::
operator+= (CursorWindow::Dialog::Element *e)
  //
  //
{
  e->dialog_ = this;

  impl_->elements_.push_back(e);

  return *this;

}

std::string const &
CursorWindow::Dialog::
completion_directory() const
{
  return impl_->curdir_;
}

void
CursorWindow::Dialog::
set_completion_directory(std::string const &s)
{
  impl_->curdir_ = s;
}



CursorWindow::Dialog::iterator
CursorWindow::Dialog::
begin()
{
  return impl_->elements_.begin();
}


CursorWindow::Dialog::iterator
CursorWindow::Dialog::
end()
{
  return impl_->elements_.end();
}

void
CursorWindow::Dialog::Ok::
draw_input_area(viewport *v, bool highlighted)
{
  v->set_text_attribute( highlighted ? CursorWindow::normal
                                     : CursorWindow::reversed
                       );
                
  row_col pos = v->curpos();
                
  v->write("[OK]");

  v->set_curpos(pos.row_, pos.col_ + 1);

}




bool
CursorWindow::Dialog::String::
compute_actual_width(viewport *v)
{
  bool rv = false;

  width_ = input_width_;            // actual equals requested

  row_col size = v->size();

  if(input_ + width_ > size.col_)   // if actual won't fit in window, shrink it
  {
    width_ = size.col_ - input_;    // to the size between actual input column
                                    // and the end of the window
  }

  if(col_ < 0)
    col_ = 0;

  int maxlen = value_.size();

  if(col_ > maxlen )                // col_ is allowed to be exactly maxlen
    col_ = maxlen;

  if(col_ - offset_ >= width_ ||    // logical cursor not in the visible area
     col_ < offset_
    )
  {
    offset_ = col_ - width_/2;      // center logical cursor pos in the window

    if(offset_ < 0)
      offset_ = 0;

    rv = true;                      // offset_ changed
  }


  if(offset_ > maxlen )
  {
    offset_ = maxlen;

    rv = true;                      // offset_ changed
  }

  if(col_ > maxlen)
    col_ = maxlen;


  return rv;

}

void
CursorWindow::Dialog::String::
handle_paging(viewport *v)
{
  row_col pos = v->curpos();

  if(compute_actual_width(v))
  {
    v->set_curpos(pos.row_, input_);

    draw_input_area(v,true);

  }

  v->set_curpos(pos.row_, input_ + col_ - offset_);


}


void
CursorWindow::Dialog::String::
draw_input_area(viewport *v, bool highlighted)
{
  // this code assumes that the cursor is correctly positioned at the
  // beginning of the input area and the cursor position is captured for
  // future use by handle_key

  row_col pos = v->curpos();

  input_ = pos.col_;        // actual_input_col_ from the impl_ in the dialog.

  compute_actual_width(v);  // and offset_

  int drawlen = value_.size();

  drawlen -= offset_;

  if(drawlen > width_)
    drawlen = width_;

  v->set_text_attribute( highlighted ? CursorWindow::normal
                                     : CursorWindow::reversed
                       );

  if(password_)
  {
    v->write('*', drawlen);
  }
  else
  {
    v->write( string(value_.begin() + offset_,
                     value_.begin() + offset_ + drawlen
                    )
            );
  }
        
  if(drawlen < width_)
    v->write(' ', width_ - drawlen);

  v->set_curpos(pos.row_, pos.col_ + col_ - offset_);

}

void CursorWindow::Dialog::String::
setColumn(int col)
{
    col_ = (size_t(col) <= value_.size() ) ? col : 0;
};


void
CursorWindow::Dialog::String::
handle_key(viewport *v, int key)
{
  //
  // Find out where the cursor actually is

  compute_actual_width(v);

  switch(CursorWindow::func[key])
  {
    case CursorWindow::func_home:
      {
        col_ = 0;
        
        handle_paging(v);
        
      }
      break;

    case CursorWindow::func_end:
      {
        col_ = value_.size();
        
        handle_paging(v);
        
      }
      break;

    case CursorWindow::func_right:
      {
        ++col_;
        
        handle_paging(v);
        
      }
      break;


    case CursorWindow::func_left:
      {
        --col_;
        
        handle_paging(v);
        
      }
      break;

    case CursorWindow::func_dc_prev:

      if(col_ == 0)
      {
        v->beep();
        return;
      }

      --col_;
      compute_actual_width(v);
      {
        row_col pos = v->curpos();
        
        v->set_curpos(pos.row_, input_ + col_ - offset_);
        
      }

      // drop through

    case CursorWindow::func_dc:
      {
        int maxlen = value_.size();
        
        if(col_ < maxlen)
        {
           value_.erase( value_.begin() + col_ );
        
           int tail_length = maxlen - col_ - 1;
        
           string tail_text(value_.begin() + col_,
                            value_.begin() + col_ + tail_length
                           );
                        
           tail_text += " ";
        
           if(password_)
           {
             v->write('*', tail_text.size()-1 );
             v->write(' ');
        
           }
           else
             v->write( tail_text );

           handle_paging(v);

        }
        else
          v->beep();
      }
      break;

    case CursorWindow::func_clreol:
      {
        int maxlen = value_.size();
        
        if(col_ < maxlen)
        {
           value_.erase( value_.begin() + col_, value_.end() );
        
           int tail_length = maxlen - col_;
        
           string tail_text(tail_length, ' ');
                        
           if(password_)
           {
             v->write(' ', tail_text.size());
        
           }
           else
             v->write( tail_text );

           handle_paging(v);

        }
        else
          v->beep();
      }
      break;

    case CursorWindow::func_tab:
      {
        // perform tab completion
        
        size_t col = col_;
        
        if(col > value_.size())
          col = value_.size();
        
        // col is now within the valid range of characters in
        // the value string -- or it is at the end

        if(value_[0] == '~')
        { // expand tildes

          FileName tmp(value_);

          value_ = tmp.expand_tildes();

          // paint the input area as blank
          
          row_col pos = v->curpos();
          
          v->set_curpos(pos.row_, input_);
          
          v->write(' ', width_);

          // draw the new value

          col_ = value_.size();
          
          compute_actual_width(v);
          
          v->set_curpos(pos.row_, input_);
          
          draw_input_area(v,true);
          
          v->set_curpos(pos.row_, input_ + col_ - offset_);

        } // expand tildes


        
        if(col != 0 &&
           col == value_.size()
          )
        {
          // expand the last non-blank section of the string
          // (can't expand blanks so quit if the last char is blank)
        
          if(value_[col-1] == ' ')
          {
            v->beep();
            break;
          }
        
          int word_start = col;
        
          while(word_start && value_[word_start-1] != ' ')
            --word_start;
        
          // either at beginning of string or on the first
          // char of the last word
        
          std::string last_word(value_.begin() + word_start,
                                value_.end()
                               );
                        
          FileName path(last_word);
        
          if(last_word[0] != '/' &&
             !(last_word[1] == ':' && (last_word[2] == '\\' ||
                                       last_word[2] == '/'
                                      )
              )
            )
          {
            //
            // the completion string doesn't have a directory component
            // specified
            //
            path = dialog_->completion_directory() + last_word;
          }
        
          if(path.is_dir())
          {
            // just put a slash on the names of directories
        
            if(value_[value_.size()-1] == '/')
            {
              v->beep();
              break;
            }
        
            value_ += '/';
            v->write('/');
        
            col_ = value_.size();
            handle_paging(v);
        
          }
          else
          {
             FileName::sorted_names_t matching;
             std::string              replacement;
        
             int matches = FileName::find_matching(path + "*", &matching);
        
             if(matches == 0)
             {
               v->beep();
               break;
             }
        
             if(matches == 1)
               replacement = *matching.begin();
             else
             {
               CursorWindow::Selection selection("pick one of the following");
        
               FileName::sorted_names_t::iterator first = matching.begin(),
                                                  last  = matching.end();
                                        
               while(first != last)
               {
                 FileName const& cur = *first++;
                
                 selection += cur;
                
               }
        
               if(selection.popup(v->window()))
                 break;
                
               replacement = selection.selection_;
                
             }
        
             // erase deleted data
        
             value_.erase(value_.begin() + word_start, value_.end());
        
             // paint the input area as blank
        
             row_col pos = v->curpos();
        
             v->set_curpos(pos.row_, input_);
        
             v->write(' ', width_);
        
             // replace the trailing string with the
             // text of interest
        
                
             value_ = path.dirname() + replacement;
        
             col_ = value_.size();
        
             compute_actual_width(v);
        
             v->set_curpos(pos.row_, input_);
        
             draw_input_area(v,true);
        
             v->set_curpos(pos.row_, input_ + col_ - offset_);
        
        
          }
        
        
        }
        else
          v->beep();
        
      }
      break;


    case CursorWindow::func_nextwd:
      {
        string::iterator start = value_.begin() + col_;
        string::iterator end = value_.end();
        
        string::iterator word_start = word.begin();
        string::iterator word_end   = word.end();
        
        start = StrTool::find_next_word(start, end, word_start, word_end);
        
        col_ = start - value_.begin();
        
        handle_paging(v);
                                                
        
      }
      break;

    case CursorWindow::func_prevwd:
      {
        string::iterator start = value_.begin() + col_;
        string::iterator beg = value_.begin();
        
        string::iterator word_start = word.begin();
        string::iterator word_end   = word.end();
        
        start = StrTool::find_prev_word(start,
                                        beg, value_.end(),
                                        word_start, word_end
                                       );
        
        col_ = start - beg;
        
        handle_paging(v);
                                                
        
      }
      break;



    case CursorWindow::func_data:

      if(key < 0x100 && key > 0)
      {
         value_.insert( value_.begin() + col_, (char)(key) );
        
         int maxlen = value_.size();
        
         int tail_length = maxlen - col_;

         int char_cells_in_window = width_ - (col_ - offset_);

         if(tail_length > char_cells_in_window)
             tail_length = char_cells_in_window;
        
         string tail_text(value_.begin() + col_,
                          value_.begin() + (col_ + tail_length)
                         );
        
         if(password_)
         {
           v->write('*', tail_text.size());
         }
         else
           v->write( tail_text );
        
         ++col_;
        
         handle_paging(v);
        
      }
      break;


  }
}

struct SaveRestoreActiveWindow
{

  port*  active_viewport;

  SaveRestoreActiveWindow(CursorWindow *w)
  {
    active_viewport =  w->window_->viewport_[w->window_->active_viewport_];
  }

  ~SaveRestoreActiveWindow()
  {
    if(active_viewport)
    {
      CursorWindow::viewport vp(active_viewport);

      vp.activate();
    }
  }




};


bool
CursorWindow::Dialog::
popup(CursorWindow *w)
{
  SaveRestoreActiveWindow _sr(w);

  // determine the dimensions of the dialog by iterating
  // over the element list and computing the width of
  // labels and the width of the input fields.  To this
  // horizontal width, add spacing between the labels and
  // the input field area.
  //
  // The height is the number of input fields plus the
  // 1 for the tile, plus spacing.
  //
  // The dialog will be popped up in the center of the
  // screen and will be in reversed video.
  //
  // After computing the screen layout, draw the dialog and
  // let the user edit fields.  return a flag indicating
  // that the user aborted the input operation.

  impl_->desired_height_ = impl_->first_input_row_;

  impl_->desired_label_width_ = 0;
  impl_->desired_input_width_ = 0;

  iterator f = begin(),
           l = end();
        
  while(f != l)
  {
    Element *e = *f;

    int wl = e->label_.size();
    int wi = e->input_width_;

    if(wl > impl_->desired_label_width_)
      impl_->desired_label_width_ = wl;

    if(wi > impl_->desired_input_width_)
      impl_->desired_input_width_ = wi;

    ++impl_->desired_height_;
    ++f;

  }

  impl_->desired_input_column_ = impl_->label_indent_ +
                                 impl_->desired_label_width_ +
                                 impl_->gutter_width_;
                                

  impl_->desired_width_ = impl_->desired_input_column_ +
                          impl_->desired_input_width_;

  int title_width = impl_->title_.size() + impl_->title_col_;

  if(title_width > impl_->desired_width_)
    impl_->desired_width_ = title_width;

  std::auto_ptr<viewport> v(w->new_viewport(this,viewport::floating).release());



  impl_->page_.page_top_    = begin();
  impl_->page_.current_line_= begin();

  CursorWindow::Dialog::Impl::iterator tmp = 
                               impl_->find_element(impl_->first_input_field_);

  if(tmp != end())
    impl_->page_.current_line_ = tmp;

  impl_->first_input_field_ = "";  // dont' do this again

  impl_->page_.last_line_ = end();

  v->activate();

  // pressing the Enter key is the same as doing that and also
  // pressing the Down Arrow key -- that is, it completes the
  // current field but also steps tot the next field.

  bool                      pushed_key = false;  // down arrow pushed back
  CursorWindow::input_event e;

  for(;;)
  {
    if(pushed_key)
      pushed_key = false;
    else
      e = w->read_input();

    // this code is really wrong.  we should interpret functions
    // if the CursorWindow::func[value] says its a function not
    // arbitrarily split things out.  I'll fix this later.

    if(e.type_ == CursorWindow::input_event::FunctionKey)
    {
      int func_key = CursorWindow::func[e.value_];

      switch(func_key)
      {
        case CursorWindow::func_up:

          if(impl_->page_.current_line_ != begin())
          {
             // move up
        
             bool at_top_of_page = impl_->page_.current_line_ ==
                                   impl_->page_.page_top_;
        
             impl_->draw_current_input_area(v.get(), false);

             --impl_->page_.current_line_;
        
             if(at_top_of_page)
             {
               impl_->page_.page_top_ = impl_->page_.current_line_;
               (*this)(v.get(),0); // will paint and recompute page bottom
             }

             impl_->draw_current_input_area(v.get(), true);

          }
          else
           v->beep();
        
          break;

        case CursorWindow::func_down:
        {
          CursorWindow::Dialog::iterator next_line =
              impl_->page_.current_line_;
        
          ++next_line;

          if(next_line != impl_->page_.last_line_)
          {
             // move down
        
             impl_->draw_current_input_area(v.get(), false);

             ++impl_->page_.current_line_;

             if(next_line == impl_->page_.page_bottom_)
             {
                // we have stepped off the bottom of the page
        
                ++impl_->page_.page_top_;

                if(impl_->page_.page_bottom_ != impl_->page_.last_line_)
                {
                  ++impl_->page_.page_bottom_;
                }
                
                (*this)(v.get(),0); // resets page bottom
             }
        

             impl_->draw_current_input_area(v.get(), true);
          }
          else
          {
            return false;
          }
          break;

        }

        case CursorWindow::func_enter:

           pushed_key = true;
           e.type_  = CursorWindow::input_event::FunctionKey;
           e.value_ = CursorWindow::key_down;
        
          break;
        
        case CursorWindow::func_esc:
        
          return true;

        default:
            (*impl_->page_.current_line_)->handle_key(v.get(),e.value_);
          break;
      }
    }
    else
    if(e.type_ == CursorWindow::input_event::DataKey)
    {
      switch(e.value_)
      {
        
        default:
           (*impl_->page_.current_line_)->handle_key(v.get(),e.value_);
           break;
      }
    }

  }

  return false;

}

void
CursorWindow::Dialog::
operator() (viewport* v, int cmd)
  // respond to paint commands which occur during initial drawing
  // of popups and screen resizes.
{


   //
   // paint the entire dialog in reversed video
   //

   impl_->recompute_page_info(v);

   v->set_text_attribute(CursorWindow::dialog_normal_att);
   v->set_curpos(0,0);
   v->fill_to_eos();

   // paint the title
   v->set_text_attribute(CursorWindow::dialog_title_att);
   v->set_curpos(impl_->title_row_, impl_->title_col_);
   v->write(impl_->title_);

   int      i;
   iterator scan;
   int      available_label_width = impl_->actual_input_column_ -
                                    impl_->label_indent_;

   if(available_label_width < 0)
       available_label_width = 0;

   v->set_text_attribute(CursorWindow::reversed);

 
   for(i=0, scan=impl_->page_.page_top_;
       i < impl_->page_.height_;
       ++i, ++scan
      )
   {
     Element *e = *scan;

     string label = e->label_;

     int label_width = label.size();

     if(label_width > available_label_width)
     {
       string temp(label.begin(), label.begin() + available_label_width);

       label = temp;
     }

     v->set_curpos(impl_->first_input_row_ + i,
                   impl_->actual_input_column_ - impl_->gutter_width_ -
                   label.size()
                  );
                
     v->set_text_attribute(CursorWindow::dialog_normal_att);

     v->write(label);

     v->write(": ");

     e->draw_input_area(v, scan == impl_->page_.current_line_);

   }

   impl_->draw_current_input_area(v, true);

}

class CursorWindow::Selection::Impl
  //
  //
{
public:

  typedef CursorWindow::Selection::rep_type   rep_type;
  typedef rep_type::iterator                  iterator;

  string title_;

  int desired_width_;
  int desired_height_;
  int actual_width_;
  int actual_height_;

  iterator page_top_;      // first visible line at top of display
  iterator page_bottom_;   // 1 line past bottom of display area or
                           // end of list
  iterator current_line_;  // cursor line

  iterator begin_;         // of list
  iterator end_;           // of list

  int title_col_;          // where title is displayed
  int title_row_;          // ditto
  int input_row_;          // where first selection appears
  int input_col_;          // ditto

  size_t auto_complete_column_;  // column where next auto_complete char
                                 // operation will search -- gets incremented
                                 // with every non-function key you type.
                                 // Function keys set it back to column 0.
                                 // When you type a non-function key, the
                                 // cursor will move to the line that has that
                                 // key in the auto-complete column


  void compute_page_info(viewport *v)
    //
    // This function computes a bunch of variales based on the available
    // width and height of the screen and given the current position within
    // the selection list.  It scales the viewport to the minimum size
    // available or needed -- that is, if we need less than we are given,
    // resize the viewport to the smaller size.  In any case, adjust various
    // variables used in displaying so we display correctly.
    //
  {
    row_col size = v->window()->size();

    // assume we are using a box around the selection, so remove the
    // top, bottom, left, and right character cells from the comoputed size

    size.row_ -= 2;
    size.col_ -= 2;

    //
    //  compute the usable size of the selection box.
    //


    if(desired_height_ >= size.row_ )
      actual_height_ = size.row_;
    else
      actual_height_ = desired_height_;


    if(desired_width_ > size.col_)
      actual_width_ = size.col_;
    else
      actual_width_ = desired_width_;

    row_col available = v->window()->size();

    row_col upper_left( (available.row_ - actual_height_)/2,
                                      (available.col_ - actual_width_)/2
                                    );

    v->move(upper_left, row_col(actual_height_+1, actual_width_+1));


    int page_height = input_row_;

    iterator scan =  page_top_;

    bool current_found = false;

    while(scan != end_ && page_height < actual_height_)
    {
      if(scan == current_line_)
        current_found = true;

      ++scan;
      ++page_height;
    }

    page_bottom_ = scan;

    if(!current_found)
      current_line_ = page_top_;

  }

  void draw_current_line(viewport *v, bool highlighted)
    //
    // compute the screen location of current_line_ and draw the
    // line either highlighted or not.
    //
  {
    int row_offset = 0;
    size_t avail_width = actual_width_ - input_col_;

    iterator scan = page_top_;

    while(scan != current_line_ && scan != page_bottom_)
    {
      ++row_offset;
      ++scan;
    }

    v->set_curpos(input_row_ + row_offset, input_col_);

    v->set_text_attribute(highlighted ? CursorWindow::normal : 
                                        CursorWindow::dialog_normal_att);

    if(current_line_->size() > avail_width)
    {

      string avail_text(current_line_->substr(current_line_->size() - (avail_width -4),
                                              current_line_->size()
                                             )
                       );

      v->write(".../");
      v->write(avail_text);

    }
    else
      v->write(*current_line_);

    v->fill_to_eol();
    {
      using namespace CursesInterface;
      v->set_curpos(input_row_ + row_offset, actual_width_);
      v->write(line_chars[VL_MIDDLE],1);
    }
    v->set_curpos(input_row_ + row_offset, input_col_ + auto_complete_column_);

  }

  void draw_current_line(std::auto_ptr<viewport> &v, bool highlighted)
  {
    draw_current_line(v.get(), highlighted);
  }


};

CursorWindow::Selection::
Selection(string title)
{
  selection_ = "";

  impl_ = new Impl;

  impl_->title_ = title;

  impl_->title_row_ = 0;
  impl_->title_col_ = 0;
  impl_->input_row_ = 1;
  impl_->input_col_ = 2;

}

CursorWindow::Selection::
~Selection()
{
  delete impl_;

  impl_ = 0;
}

template<class Iterator>
inline
int count_distance(Iterator a, Iterator b)
{
  int rv=0;

  while(a != b)
  {
    ++rv;
    ++a;
  }

  return rv;
}


bool
CursorWindow::Selection::
popup(CursorWindow* w)
  //
  //
{
  SaveRestoreActiveWindow _sr(w);

  std::auto_ptr<viewport> v(w->new_viewport(this,viewport::floating).release());

  int desired_width = 0;
  int desired_height= 0;

  impl_->auto_complete_column_ = 0;

  rep_type::iterator scan = rep_.begin(),
                     end  = rep_.end();
                
  while(scan != end)
  {
    int s = scan->size();

    ++desired_height;

    if(s > desired_width)
      desired_width = s;

      ++scan;

  }

  desired_height += impl_->input_row_;
  desired_width  += impl_->input_col_;

  if( int(impl_->title_.size())+3 > (impl_->title_col_ + desired_width) )
    desired_width = impl_->title_.size() + 3 + impl_->title_col_;

  impl_->desired_width_  = desired_width;
  impl_->desired_height_ = desired_height;
  impl_->page_top_       = rep_.begin();
  impl_->page_bottom_    = rep_.end();
  impl_->current_line_   = rep_.begin();
  impl_->begin_          = rep_.begin();
  impl_->end_            = rep_.end();


  v->activate(); // recomputes actual height etc

  CursorWindow::input_event e;

  selection_.resize(0);  // return value is empty string until a selection occurs

  for(;;)
  {
    e = w->read_input();

    int edit_func = w->func[e.value_];

    if(edit_func != CursorWindow::func_data)
    {
      impl_->auto_complete_column_ = 0;
    }

    switch(edit_func)
    {
      case CursorWindow::func_down:
          if(impl_->current_line_ != impl_->page_bottom_)
          {
            
            impl_->draw_current_line(v.get(),false);
            ++impl_->current_line_;

            if(impl_->current_line_ == impl_->page_bottom_)
            {
              // page down 1 line
        
              if(impl_->page_bottom_ != impl_->end_)
              {
                ++impl_->page_top_;
                (*this)(v.get(),0);
              }
              else
                --impl_->current_line_;
        
            }

            impl_->draw_current_line(v.get(),true);

          }
          else
          if(impl_->page_bottom_ != impl_->end_)
          {
            ++impl_->page_top_;
            ++impl_->current_line_;
            (*this)(v.get(),0);
            impl_->draw_current_line(v.get(),true);
          }
          else
            w->beep();
        break;
      case CursorWindow::func_up:
          if(impl_->current_line_ != impl_->page_top_)
          {
            impl_->draw_current_line(v, false);
            --impl_->current_line_;
            impl_->draw_current_line(v, true);
          }
          else
          if(impl_->page_top_ != impl_->begin_)
          {
            --impl_->page_top_;
            --impl_->current_line_;
            (*this)(v.get(), 0);
            impl_->draw_current_line(v, true);
          }
        break;
      case CursorWindow::func_prior:
        {
          int page_height = impl_->actual_height_ - impl_->input_row_;

          if(impl_->page_top_ == impl_->begin_)
          {
            impl_->current_line_ = impl_->page_top_;
          }
          else
          {
            while(page_height && impl_->page_top_ != impl_->begin_)
            {
              --page_height;
              --impl_->page_top_;
              --impl_->current_line_;
            }
          }
        
          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        
        
        
        }
        break;
      case CursorWindow::func_next:
        {
          int page_height = count_distance(impl_->page_top_, impl_->page_bottom_);

          if(impl_->page_bottom_ == impl_->end_)
          {
            goto page_bottom;
          }
          else
          {        
            while(page_height && impl_->page_bottom_ != impl_->end_)
            {
              --page_height;
              ++impl_->page_top_;
              ++impl_->current_line_;
              ++impl_->page_bottom_;
            }
          }
        
          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        
        }
        break;
      case CursorWindow::func_top:

          impl_->draw_current_line(v, false);

          impl_->page_top_     = impl_->begin_;
          impl_->current_line_ = impl_->begin_;

          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);

        break;
      case CursorWindow::func_bottom:

page_bottom:

          impl_->draw_current_line(v, false);

          impl_->page_top_     = impl_->end_;
          --impl_->page_top_;

          impl_->current_line_ = impl_->page_top_;

          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        break;

      case CursorWindow::func_esc:
        return true;

      case CursorWindow::func_enter:

        if(impl_->current_line_ != impl_->end_)
          selection_ = *impl_->current_line_;
        else
          return true;

        return false;

      case CursorWindow::func_data:
        {
          rep_type::iterator cur = impl_->current_line_,
                             end = rep_.end();

          int count=0;
          bool foundit=false;

          while(cur != end)
          {
            string const& s = *cur;

            if(s.size() > impl_->auto_complete_column_)
            {
              if(s[impl_->auto_complete_column_] == e.value_)
              {
                // hah, found a line with the right character in the
                // right column
                foundit = true;
                break;
              }
            }
            else
            {
              break;
            }

            ++cur;
            ++count;
          }

          if(foundit)
          {
            impl_->draw_current_line(v, false);

            ++impl_->auto_complete_column_;

            while(count--)
            {
              if(impl_->current_line_ == impl_->page_bottom_)
              {
                ++impl_->current_line_;

                int page_size = impl_->actual_height_ -
                                impl_->input_row_;

                while(page_size-- && impl_->page_bottom_ != rep_.end())
                {
                  ++impl_->page_top_;
                  ++impl_->page_bottom_;
                }

              }
              else
              {
                ++impl_->current_line_;
              }
            }

            (*this)(v.get(),0);

            impl_->draw_current_line(v, true);

          }


        }
        break;

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

    v->set_curpos(impl_->input_row_ +
                    count_distance(impl_->page_top_, impl_->current_line_),
                  impl_->input_col_ + impl_->auto_complete_column_
                 );

  }


  return true;
}

static 
void 
output_short_string(viewport *v, string const &s, size_t maxlen)
{
  if(s.size() <= maxlen)
    v->write(s);
  else
  {
     int siz = (int)(s.size());
     int ml  = (int)(maxlen);

     int index = siz - (ml - 4);

     if(index < 0)
       index = 0;

     string tmp( s.substr((size_t)(index), s.size()) );

     v->write(".../");
     v->write(tmp);

  }
}


void 
CursorWindow::Selection::
operator() (viewport *v, int cmd)
{
  impl_->compute_page_info(v);

  v->set_text_attribute(CursorWindow::reversed);

  v->set_curpos(0,0);
  v->box(impl_->actual_width_+1, impl_->actual_height_+1, true, impl_->title_);


  v->set_text_attribute(CursorWindow::dialog_normal_att);

  int row = impl_->input_row_;

  rep_type::iterator scan = impl_->page_top_,
                     end  = impl_->page_bottom_;
                
  int input_row =0;

  size_t avail_width = impl_->actual_width_ - impl_->input_col_;

  while(scan != end)
  {
    v->set_curpos(row, impl_->input_col_);

    if(scan == impl_->current_line_)
    {
      v->set_text_attribute(CursorWindow::normal);
      output_short_string(v, *scan, avail_width);

      v->fill_to_eol();

      {
        using namespace CursesInterface;

        v->set_curpos(row, impl_->actual_width_);

        v->write(line_chars[VL_MIDDLE], 1);

      }

      v->set_text_attribute(CursorWindow::dialog_normal_att);

      input_row = row;

    }
    else
      output_short_string(v, *scan, avail_width);

    ++scan;
    ++row;

  }

  v->set_curpos(input_row, impl_->input_col_ + impl_->auto_complete_column_);


}




string
CursorWindow::
select_file(string const &title, string const &pattern, CursorWindow* w)
  // Let the user select a file from a list of names.  Return empty string
  // if the user aborts with the esc key.
{

  FileName::sorted_names_t names;

  int name_count = FileName::find_matching(pattern, &names);

  if(name_count == 0)
    return "";

  Selection s(title);

  FileName::sorted_names_t::iterator scan = names.begin(),
                                     end  = names.end();
                                
  while(scan != end)
  {
    s += *scan++;
  }

  if(s.popup(w))
    return "";

  return s.selection_;


}

std::auto_ptr<viewport>
viewport::
hsplit(viewport::repaint_handler* rh)
{
  std::auto_ptr<viewport> rv( new viewport(port_->window_, rh) );

  row_col origin(port_->origin());
  row_col size  (port_->size());

  if(size.col_ > 20 && size.row_ > 3)
  {
    // enough room to perform a real split

    int available_width = size.col_;

    int target_width = available_width/2;

    int parent_width = available_width - target_width;

    size.col_ = parent_width;

    move(origin, size); // move parent to its new size

    size.col_ = target_width;

    origin.col_ += parent_width;

  }

  rv->move(origin, size);


  return rv;
}

std::auto_ptr<viewport>
viewport::
vsplit(viewport::repaint_handler* rh)
{
  std::auto_ptr<viewport> rv( new viewport(port_->window_, rh));

  row_col origin(port_->origin());
  row_col size  (port_->size());

  if(size.col_ > 20 && size.row_ > 3)
  {
    // enough room to perform a real split

    int available_height = size.row_;

    int target_height = available_height/2;

    int parent_height = available_height - target_height;

    size.row_ = parent_height;

    move(origin, size); // move parent to its new size

    size.row_ = target_height;

    origin.row_ += parent_height;

  }

  rv->move(origin, size);

  return rv;

}

int
CursorWindow::
get_viewports(std::list<CursorWindow::viewport> * viewports)
{
  int rv=0;

  while(rv < window_->viewports_)
  {
    viewports->push_back(viewport(window_->viewport_[rv]) );
    ++rv;
  }

  return rv;

}

CursorWindow::viewport::
viewport(viewport const &r)
{
  port_ = (port*)(r.port_);
  owned_= false;

}

CursorWindow::viewport::repaint_handler *
CursorWindow::viewport::
get_repaint_handler()
{
  return port_->handler_;
}

void
CursorWindow::viewport::
set_repaint_handler(CursorWindow::viewport::repaint_handler *r)
{
  port_->handler_ = r;
}


string
CursorWindow::Dialog::
element_value(string const &name)
{
  iterator first = begin(),
           last  = end();
        
  while(first != last)
  {
    Element* e = *first++;

    if(e->name_ == name)
      return e->value_;

  }

  return "";
}

CursorWindow::Dialog::Impl::iterator
CursorWindow::Dialog::Impl::
find_element(string const &name)
{
  iterator first = elements_.begin(),
           last  = elements_.end();
        
  while(first != last)
  {
    Element* e = *first;

    if(e->name_ == name)
      return first;

    ++first;

  }

  return last;
}

class CursorWindow::Message::Impl
  //
  //
{
public:

  typedef CursorWindow::Message::rep_type   rep_type;
  typedef rep_type::iterator                  iterator;

  string title_;

  int desired_width_;
  int desired_height_;
  int actual_width_;
  int actual_height_;

  iterator page_top_;      // first visible line at top of display
  iterator page_bottom_;   // 1 line past bottom of display area or
                           // end of list
  iterator current_line_;  // cursor line

  iterator begin_;         // of list
  iterator end_;           // of list

  int title_col_;          // where title is displayed
  int title_row_;          // ditto
  int input_row_;          // where first Message appears
  int input_col_;          // ditto

  string search_text_;     // most recent search string


  void compute_page_info(viewport *v)
    //
    // This function computes a bunch of variales based on the available
    // width and height of the screen and given the current position within
    // the Message list.  It scales the viewport to the minimum size
    // available or needed -- that is, if we need less than we are given,
    // resize the viewport to the smaller size.  In any case, adjust various
    // variables used in displaying so we display correctly.
    //
  {
    row_col size = v->window()->size();

    if(desired_height_ > size.row_)
      actual_height_ = size.row_;
    else
      actual_height_ = desired_height_;


    if(desired_width_ > size.col_)
      actual_width_ = size.col_;
    else
      actual_width_ = desired_width_;

    row_col available = v->window()->size();

    row_col upper_left( (available.row_ - actual_height_)/2,
                                      (available.col_ - actual_width_)/2
                                    );

    v->move(upper_left, row_col(actual_height_, actual_width_));


    int page_height = input_row_;

    iterator scan =  page_top_;

    bool current_found = false;

    while(scan != end_ && page_height < actual_height_)
    {
      if(scan == current_line_)
        current_found = true;

      ++scan;
      ++page_height;
    }

    page_bottom_ = scan;

    if(!current_found)
      current_line_ = page_top_;

  }

  int move_to_current_line(viewport *v)
      // position the cursor on the current input line and
      // 
  {
    int row_offset = 0;

    iterator scan = page_top_;

    while(scan != current_line_ && scan != page_bottom_)
    {
      ++row_offset;
      ++scan;
    }

    v->set_curpos(input_row_ + row_offset, input_col_);

    return row_offset;
  }


  void draw_current_line(viewport *v, bool highlighted)
    //
    // compute the screen location of current_line_ and draw the
    // line either highlighted or not.
    //
  {
    int row_offset=0;
    
    row_offset = move_to_current_line(v);

#if 0
    v->set_text_attribute(highlighted ? CursorWindow::normal :
                                        CursorWindow::dialog_normal_att
                         );
#else
    v->set_text_attribute(CursorWindow::dialog_normal_att);
#endif

    v->write(*current_line_);
    v->fill_to_eol();

    v->set_curpos(input_row_ + row_offset, input_col_);



  }

  void draw_current_line(std::auto_ptr<viewport> &v, bool highlighted)
  {
    draw_current_line(v.get(), highlighted);
  }


};

CursorWindow::Message::
Message(string title)
{
  impl_ = new Impl;

  impl_->title_ = title;

  impl_->title_row_ = 0;
  impl_->title_col_ = 0;
  impl_->input_row_ = 1;
  impl_->input_col_ = 2;

}

CursorWindow::Message::
~Message()
{
  delete impl_;

  impl_ = 0;
}

void
CursorWindow::Message::
popup(CursorWindow* w)
  //
  //
{
  SaveRestoreActiveWindow _sr(w);

  std::auto_ptr<viewport> v(w->new_viewport(this,viewport::floating).release());

  int desired_width = 0;
  int desired_height= 0;

  rep_type::iterator scan = rep_.begin(),
                     end  = rep_.end();
                
  while(scan != end)
  {
    int s = scan->size();

    ++desired_height;

    if(s > desired_width)
      desired_width = s;

      ++scan;

  }

  desired_height += impl_->input_row_;
  desired_width  += impl_->input_col_;

  if( int(impl_->title_.size()) > (impl_->title_col_ + desired_width) )
    desired_width = impl_->title_.size() + impl_->title_col_;

  impl_->desired_width_  = desired_width;
  impl_->desired_height_ = desired_height;
  impl_->page_top_       = rep_.begin();
  impl_->page_bottom_    = rep_.end();
  impl_->current_line_   = rep_.begin();
  impl_->begin_          = rep_.begin();
  impl_->end_            = rep_.end();

  v->activate();


  CursorWindow::input_event e;

  for(;;)
  {

    {
      // work around for bug in nested popups -- I should fix this but the
      // work around is too easy.

      // move the cursor around to overcome a repaint bug associated with
      // nested popups...
      w->set_curpos(0,0);
      w->refresh();
      w->set_curpos(1,1);
      w->refresh();
    }


    impl_->move_to_current_line(v.get());

    e = w->read_input();

    int edit_func = w->func[e.value_];

    switch(edit_func)
    {
      case CursorWindow::func_down:

          if(impl_->current_line_ != impl_->page_bottom_)
          {
            impl_->draw_current_line(v.get(),false);
            ++impl_->current_line_;

            if(impl_->current_line_ == impl_->page_bottom_)
            {
              // page down 1 line
        
              if(impl_->page_bottom_ != impl_->end_)
              {
                ++impl_->page_top_;
                (*this)(v.get(),0);
              }
              else
                --impl_->current_line_;
        
            }

            impl_->draw_current_line(v.get(),true);

          }
          else
          if(impl_->page_bottom_ != impl_->end_)
          {
            ++impl_->page_top_;
            ++impl_->current_line_;
            (*this)(v.get(),0);
            impl_->draw_current_line(v.get(),true);
          }
          else
            w->beep();
        break;
      case CursorWindow::func_up:
          if(impl_->current_line_ != impl_->page_top_)
          {
            impl_->draw_current_line(v, false);
            --impl_->current_line_;
            impl_->draw_current_line(v, true);
          }
          else
          if(impl_->page_top_ != impl_->begin_)
          {
            --impl_->page_top_;
            --impl_->current_line_;
            (*this)(v.get(), 0);
            impl_->draw_current_line(v, true);
          }
        break;
      case CursorWindow::func_prior:
        {
          int page_height = count_distance(impl_->page_top_, impl_->page_bottom_);

          if(page_height && impl_->page_top_ != impl_->begin_)
          {
              while(page_height && impl_->page_top_ != impl_->begin_)
              {
                --page_height;
                --impl_->page_top_;
                --impl_->current_line_;
              }
          }
          else
          {
             impl_->current_line_ = impl_->page_top_;
          }
        
          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        
        
        }
        break;
      case CursorWindow::func_next:
        {
          int page_height = count_distance(impl_->page_top_, impl_->page_bottom_);
        
          if(page_height && impl_->page_bottom_ != impl_->end_)
          {
              while(page_height && impl_->page_bottom_ != impl_->end_)
              {
                --page_height;
                ++impl_->page_top_;
                ++impl_->current_line_;
                ++impl_->page_bottom_;
              }
          }
          else
          {
              impl_->current_line_ = impl_->page_bottom_;

              if(impl_->current_line_ == impl_->end_ && impl_->begin_ != impl_->end_)
              {
                 --impl_->current_line_;
              }

          }

          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        
        }
        break;
      case CursorWindow::func_top:

          impl_->draw_current_line(v, false);

          impl_->page_top_     = impl_->begin_;
          impl_->current_line_ = impl_->begin_;

          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);

        break;
      case CursorWindow::func_bottom:

          impl_->draw_current_line(v, false);

          impl_->page_top_     = impl_->end_;
          --impl_->page_top_;

          impl_->current_line_ = impl_->page_top_;

          (*this)(v.get(),0);

          impl_->draw_current_line(v, true);
        break;

      case CursorWindow::func_esc:
        return;

      case CursorWindow::func_enter:
        return;


      case CursorWindow::func_find:
         {
             Dialog d("    Search help    ");

             d += new Dialog::String("text", 
                                 "    For",
                                 impl_->search_text_,
                                 20
                                );

             bool scrollDown = false;

             if(!d.popup(w))
             {
                impl_->search_text_ = d.element_value("text");

                rep_type::iterator scan = impl_->current_line_;

                while(scan != impl_->end_)
                {
                    if(scan == impl_->page_bottom_)
                       scrollDown = true;

                    if(StrTool::find(impl_->search_text_, *scan, true) < scan->size())
                    {
                       break;
                    }

                    ++scan;
                }


                if(scan != impl_->end_)
                {
                    impl_->draw_current_line(v, false);

                    if(scrollDown)
                    {
                        impl_->page_top_ = scan;

                        impl_->current_line_ = impl_->page_top_;

                        (*this)(v.get(),0);

                    }
                    else
                    {
                        impl_->current_line_ = scan;
                    }

                    impl_->draw_current_line(v, true);
                }
                else
                  w->beep();
                 
             }

         }
         break;

      case CursorWindow::func_findnxt:
         {
                rep_type::iterator scan = impl_->current_line_;

                ++scan;

                bool scrollDown = false;

                while(scan != impl_->end_)
                {
                    if(scan == impl_->page_bottom_)
                       scrollDown = true;

                    if(StrTool::find(impl_->search_text_, *scan, true) < scan->size())
                    {
                       break;
                    }

                    ++scan;
                }


                if(scan != impl_->end_)
                {
                    impl_->draw_current_line(v, false);
                    
                    if(scrollDown)
                    {
                        impl_->page_top_ = scan;

                        impl_->current_line_ = impl_->page_top_;

                        (*this)(v.get(),0);

                    }
                    else
                    {
                        impl_->current_line_ = scan;
                    }
                    
                    impl_->draw_current_line(v, true);
                }
                else
                   w->beep();
                 

         }
         break;

      case CursorWindow::func_data:

         // user has pressed a printable key

         switch(e.value_)
         {
            case 'q':
            case 'Q':
              return;
         }

         break;

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

  }

}




void CursorWindow::Message::
operator() (viewport *v, int cmd)
{
  impl_->compute_page_info(v);

  v->set_text_attribute(CursorWindow::dialog_normal_att);

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

  v->set_text_attribute(CursorWindow::dialog_title_att);
  v->set_curpos(impl_->title_row_, impl_->title_col_);
  v->write(impl_->title_);

  v->set_text_attribute(CursorWindow::dialog_normal_att);

  int row = impl_->input_row_;

  rep_type::iterator scan = impl_->page_top_,
                     end  = impl_->page_bottom_;
                

  while(scan != end)
  {
    v->set_curpos(row, impl_->input_col_);

#if 0
    if(scan == impl_->current_line_)
    {
      v->set_text_attribute(CursorWindow::normal_att);
      v->write(*scan);
      v->fill_to_eol();
      v->set_text_attribute(CursorWindow::dialog_normal_att);
    }
    else
#endif
      v->write(*scan);

    ++scan;
    ++row;

  }

}


void
CursorWindow::
resize_viewports(row_col const &old_size, row_col const &new_size)
{
  window_->resize_viewports(old_size, new_size);
  window_->repaint_ports();
}


CursorWindow::FileSelector::
FileSelector(std::string const &title,
             std::string const &searchPattern,
             std::string const &startFile
            )
:  title_(title)
,  searchPattern_(searchPattern)
,  startFile_(startFile)
,  noRepaint_(false)
{
   title_ += "  (F1=help)";
}

void 
CursorWindow::FileSelector::
operator() ( viewport * v, int cmd )
{

  if(noRepaint_)
    return;   // flag set only temporarily to suppress repaint of this dialog's window

  adaptToWindow(v);  // compute various dialog position size variables.

  paintDialogBackground(v);

  size_t rowTextSize = rowText_.size();

  for(int i=0; i < displayAreaHeight_; ++i)
  {
      size_t curIndex = size_t(i) + size_t(inputTopIndex_);

      if( curIndex >= rowTextSize )
         break;

      v->set_curpos(i+displayAreaRow_, displayAreaCol_);

      std::string const &name = rowText_[curIndex];

      if(curIndex == size_t(inputIndex_))
         v->set_text_attribute(CursorWindow::dialog_title_att);
      else
        v->set_text_attribute(CursorWindow::dialog_normal_att);

      v->write(name);
     
  }

}

void 
CursorWindow::FileSelector::
adaptToWindow( viewport * v)
{
   size_t windowWidth  = v->size().col_;
   size_t windowHeight = v->size().row_;

   size_t titleWidth = title_.size();

   dialogWidth_ = (maxNameWidth_+2 > titleWidth+4) ? maxNameWidth_+2 : titleWidth+4;
      // the 4 in the titlewidth comes from the dashes in the box
      // the 2 in the maxNameWidth comes from the box |'s on either side

   if(size_t(dialogWidth_) > windowWidth -2)
       dialogWidth_ = windowWidth-2;

   dialogHeight_ = rowText_.size() + 1;  // 1 each for box top and bottom

   if(size_t(dialogHeight_) > windowHeight-2)
       dialogHeight_ = windowHeight -2;

   row_ = (windowHeight - dialogHeight_)/2;
   col_ = (windowWidth  - dialogWidth_) /2;

   row_ += v->origin().row_;
   col_ += v->origin().col_;


   displayAreaRow_    = row_+1;           // skip box top line and title
   displayAreaCol_    = col_+1;           // skip box left line and left border
   displayAreaWidth_  = dialogWidth_ -3;  // minus left and right borders
   displayAreaHeight_ = dialogHeight_ -2; // minus box top and bottom

   v->set_curpos(inputIndex_ + displayAreaRow_, displayAreaCol_);

   if(inputIndex_ - inputTopIndex_ >= displayAreaHeight_)
   {
      inputTopIndex_ = inputIndex_;
   }

}


void
CursorWindow::FileSelector::
paintDialogBackground(viewport* v)
{
    //
    // fill the whole dialog with the appropriate text attributes
    //
  

    v->set_curpos(row_, col_);
    v->set_text_attribute(CursorWindow::dialog_normal_att);

    v->box(dialogWidth_, dialogHeight_, true, title_.c_str());
  

}

void
CursorWindow::FileSelector::
readFileInfo()
{
  //
  //  read the display data and update maxNameWidth_
  //

  FileName::sorted_names_t names;

  FileName tmp(searchPattern_);   
  
  searchDir_ = tmp.dirname();

  if(searchDir_.empty() || searchDir_[0] == '.')
  {
      // make sure that the searchDir_ variable contains a 
      // real directory name, not something like "./"

      char buffer[3000];

      if( getcwd(buffer, sizeof(buffer)) )
      {
          searchDir_ = buffer;
          
          searchDir_ += '/';
      }

  }


  FileName::find_matching(searchPattern_, &names);

  maxNameWidth_=0;

  rowText_.clear();

  rowText_.push_back("<ENTER A NAME>");

  CXXTLS_FOREACH(std::string const &name, names)
  {
     size_t nameWidth = name.size();

     if(nameWidth == 1 && name[0] == '.')
     {
     }
     else
     {
         if(nameWidth == 2 && (name[0] == '.' && name[1] == '.'))
         {
         }
         else
         {
             if(maxNameWidth_ < nameWidth)
                maxNameWidth_ = nameWidth;
             
             rowText_.push_back(name);
         }
     }
  }

   inputIndex_ = 0;      // cursor item index into rowText_
   inputTopIndex_ = 0;   // top in display area index into rowText_

   if(!startFile_.empty())
   {
       for(size_t i = 0; i < rowText_.size(); ++i)
       {
          if(rowText_[i] == startFile_)
          {
              inputIndex_ = i;

              if(i > 10)
              {
                  inputTopIndex_ = i-10;
              }

              break;
          }
       }
   }



}

void
CursorWindow::FileSelector::
paintRow(CursorWindow *w, int displayAreaRow)
{
   // paint the specified row assuming that it is supposed to be displayed
   // at the current time.  Paint it in the current color -- either highlighted
   // to show the cursor or not.

   int rowTextIndex = inputTopIndex_ + displayAreaRow;

   w->set_curpos(displayAreaRow_ + displayAreaRow,
                 displayAreaCol_);

   if(inputIndex_ - inputTopIndex_ == displayAreaRow)
       w->set_text_attribute(CursorWindow::dialog_title_att);
   else
       w->set_text_attribute(CursorWindow::dialog_normal_att);

   w->write(rowText_[rowTextIndex], displayAreaWidth_);

}


std::string
CursorWindow::FileSelector::
handleInput(CursorWindow *w, Viewer *parent)
{
  SaveRestoreActiveWindow _sr(w);

  std::auto_ptr<viewport> v(w->new_viewport(this,viewport::floating).release());

  CursorWindow::input_event e;

  static std::string nothing;  //empty 

  v->activate();   // paint the dialog

  for(;;)
  {
    w->set_curpos(inputIndex_ -inputTopIndex_ + displayAreaRow_, displayAreaCol_);

    e = w->read_input();

    int edit_func = w->func[e.value_];


    char pushBackKey=0;


    switch(edit_func)
    {
         default:

             // unbound function keys

             switch(e.value_)
             {
                case 0x06:   // control f
                  {

                       eraseMe(w);

                       CursorWindow::Dialog   d("Enter a different directory name");

                       d += new CursorWindow::Dialog::String("name",
                                                             "Other Directory ",
                                                             "",
                                                             40
                                                            );


                       noRepaint_ = true;
                       int rv = d.popup(w);  // we have eliminated *this from the screen by repainting without it,
                                             // but popup calls the w->activateViewport (or whatever) and it repaints
                                             // *this -- so we set the true-false wrappers around the call to prevent
                                             // this dialog from painting by mistake.
                       noRepaint_ = false;

                       if( !rv )
                       {
                           std::string value = d.element_value("name");

                           if(value != "")
                           {
                               FileName dir(value);

                               if(! dir.is_dir() )
                               {
                                  if( !dir.exists() )
                                  {
                                      CursorWindow::Message  m("That's not a valid file or directory");
                                      m += "";
                                      m += "Sorry, can't find that";

                                      m.popup(w);

                                      eraseMe(w); // repaints wholse screen
                                      

                                      this->operator()(v.get(), 0);   // repaint me
                                      break;
                                     
                                  }

                                  // dir is an existing file

                                  startFile_=dir.basename();

                                  dir = dir.dirname();

                               }

                               // dir now contains a directory

                              if(    dir[dir.size()-1] != '/' 
                                 && dir[dir.size()-1] != '\\'
                                )
                              {
                                  dir += '/';
                              }

                              dir += '*';

                              searchPattern_ = dir;

                              readFileInfo();

                              eraseMe(w);
            
                              this->operator()(v.get(),0); // repaint me in the new size




                           }
                           
                       }

                       // move the cursor around to overcome a repaint bug associated with
                       // nested popups...
                       w->set_curpos(0,0);
                       w->refresh();
                       w->set_curpos(1,1);
                       w->refresh();


                  }
                 break;

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

        case CursorWindow::func_enter:

              if(   (inputIndex_ > 1)
                 && (size_t(inputIndex_) <  rowText_.size() )
                )
              {
                 FileName file = searchDir_ + rowText_[inputIndex_];

                 if(file.is_dir())
                 {
                     eraseMe(w);

                     searchPattern_ = file + "/*";

                     readFileInfo();

                     this->operator()(v.get(),0);

                     break; 

                 }
              }

             goto promptForName;


         case CursorWindow::func_up:

             if(inputIndex_)
             {

                 if(inputIndex_ == inputTopIndex_)
                 {
                    // scroll back a line instead of moving the cursor up

                    int prev = inputTopIndex_ - 1;

                    if(prev < 0)
                       prev = 0;

                    inputIndex_ = prev;
                    inputTopIndex_ = prev;

                    this->operator() (v.get(),0);  // repaint

                 }
                 else
                 {
                     int displayOffset = inputIndex_ - inputTopIndex_;

                     --inputIndex_;
                     paintRow(w, displayOffset);
                     paintRow(w, displayOffset-1);
                 }
                 
             }
             else
                v->beep();

             break;

         case CursorWindow::func_down:
             {
                int offset = inputIndex_ - inputTopIndex_;

                int availableTextRows = int(rowText_.size()) - inputTopIndex_;

                int lastDisplayableRow;  // count of rows we can actually display

                if(availableTextRows > displayAreaHeight_)
                   lastDisplayableRow = displayAreaHeight_ -1;
                else
                   lastDisplayableRow = availableTextRows -1;

                if(offset < lastDisplayableRow)
                {
                    int displayOffset = inputIndex_ - inputTopIndex_;

                    ++inputIndex_;

                    paintRow(w, displayOffset);
                    paintRow(w, displayOffset+1);

                }
                else
                {

                  if(  int(inputTopIndex_) >= int(rowText_.size())-1 )
                  {
                      w->beep();
                  }
                  else
                  {
                      if( (int)(inputIndex_) >= int(rowText_.size())-1 )
                      {
                          w->beep();
                      }
                      else
                      {
                         ++inputTopIndex_;
                         ++inputIndex_;                
                      
                         this->operator() (v.get(),0);  // repaint
                      }
                  }

                }

             }
             break;

         case CursorWindow::func_next:
             {
                 int offset = inputIndex_ - inputTopIndex_;
                 
                 int next = inputTopIndex_ + displayAreaHeight_;
                 
                 if( next > int(rowText_.size())-1 )
                 {
                    v->beep();
                 }
                 else
                 {
                     inputTopIndex_ = next;
                     
                     inputIndex_ = next + offset;
                     
                     if(inputIndex_ > int(rowText_.size())-1 )
                     {
                        inputIndex_ = rowText_.size()-1;
                     }

                     this->operator() (v.get(),0);  // repaint
                 }
                 

             }
             break;

         case CursorWindow::func_prior:
             if(rowText_.size() == 0)
                 v->beep();
             else
             {
                 int offset = inputIndex_ - inputTopIndex_;
                 
                 int prev = inputTopIndex_ - displayAreaHeight_;
                 
                 if( prev < 0 )
                 {
                     prev = 0;
                     offset = 0;
                 }
                 
                 
                 inputTopIndex_ = prev;
                 
                 inputIndex_ = prev + offset;
                 
                 this->operator() (v.get(),0);  // repaint

             }
             break;

         case CursorWindow::func_help:
             {
                CursorWindow::Message  m("File selector Help");

                m += "Select from the file list or enter a file's name.";
                m += "";
                m += "  Standard arrows and paging keys are active.";
                m += "";
                m += "  Other keyboard interpretation:";
                m += "";
                m += "    Printable Chars   Just start typing to be prompted for a file name.";
                m += "";
                m += "    Enter             Enter a subdirectory, OR, select the file";
                m += "                      under the cursor to be prompted for modifications ";
                m += "                      to that file name (if any).";
                m += "";
                m += "    Space             SELECT the directory or file under the cursor";
                m += "";
                m += "    ^                 Navigate up a directory level";
                m += "";
                m += "    ^F                Goto another directory by name";
                m += "";

                m.popup(w);

                eraseMe(w);

                w->set_curpos(0,0);
                w->refresh();
                w->set_curpos(1,1);
                w->refresh();

             }
             break;

         case CursorWindow::func_data:

             // user has pressed a printable key
             



             switch(e.value_)
             {
                default:

                  if(e.value_ > ' ' && e.value_ <= '~' )
                  {
                     pushBackKey = e.value_;
                     goto promptForName;
                  }

                  v->beep();
                  break;


                case 'q':
                case 'Q':
                  return nothing;

                case ' ':
                  if( size_t(inputIndex_) <  rowText_.size())
                  {
                     return searchDir_ + rowText_[inputIndex_];
                  }
                  break;

                case '.':
                  {
promptForName:
                       {
                       
                           CursorWindow::Dialog   d("Manually enter a file name ");
                           
                           string startValue;
                           
                           if(pushBackKey)
                           {
                              startValue += pushBackKey;
                           }
                           else
                           if(   (inputIndex_ > 0) 
                              && (size_t(inputIndex_) < rowText_.size()) 
                             )
                              startValue = rowText_[inputIndex_];





                           CursorWindow::Dialog::String *str;

                           d += str = new CursorWindow::Dialog::String("name",
                                                                       "new file name",
                                                                       startValue,
                                                                       40
                                                                      );


                           str->setColumn( startValue.size() );
                            
                           eraseMe(w);

                           noRepaint_ = true;

                           int rv = d.popup(w);  // while the sub-dialog is popped up, don't
                                                 // repaint the parent
                           noRepaint_ = false;

                           if( !rv )
                           {
                               FileName value = d.element_value("name");
                           
                               if(value != "")
                               {
                                  if(value.is_absolute_path())
                                      return value;
                           
                                   return searchDir_ + value;
                               }
                               
                           }
                           
                           // if we get here, we need to repaint the window and move
                           // the 
                           
                           
                           this->operator()(v.get(),0);
                           
                           // force the cursor to move so as to get the screen update
                           // correct at the top of this loop.
                           
                           v->set_curpos(0,0);
                           v->set_curpos(1,1);
                           v->refresh();

                       }



                       
                  }
                  break;


                case '^':
                  {

                    FileName f(searchDir_);

                    if(f.is_root_dir())
                    {
                      v->beep();
                      break;
                    }

                    if(!f.empty())
                    {
                       // searchDir_ has a trailing / which must be removed
                       // so that a call to basename will give you the actual
                       // directory name

                       char last = f[ f.size() - 1];

                       if(last == '/' || last == '\\')
                       {
                           f.erase(f.size()-1);
                       }

                       startFile_ = f.basename();
                    }

                    eraseMe(w);

                    w->refresh();

                    FileName file = FileName(searchDir_).dirname();

                    char last = 0;

                    if(file.size() > 1)
                    {
                        last = file[file.size()-1];

                    }

                    if(last == '/' || last == '\\')
                    {
                        file.erase(file.size()-1);

                        searchPattern_ = std::string(file.dirname()) + "*";
                      
                        readFileInfo();
                      
                        this->operator()(v.get(),0);

                    }
                    else
                       v->beep();

                  }
                  break;




             }

             break;

          case CursorWindow::func_esc:
             return nothing;


    }

  }
}

std::string 
CursorWindow::FileSelector::
popup(CursorWindow* w, Viewer *parent)
{
   // return empty to string to mean the operator aborted.

  readFileInfo();

  return handleInput(w, parent);

}

void
CursorWindow::FileSelector::
eraseMe(CursorWindow *w)
{
   noRepaint_ = true;
   w->repaint_all();
   noRepaint_ = false;

}


void CursorWindow::repaint_all()
{
   row_col loc = curpos();

   window_->repaint_ports();

   set_curpos(0,0);
   set_curpos(1,1);
   set_curpos(loc);

}

} // namespace cxxtls