directoryviewer.cxx

Go to the documentation of this file.

#include <cxxtls/directoryviewer.h>
#include <cxxtls/scripttableviewer.h>
#include <cxxtls/user.h>
#include <cxxtls/etagsdb.h>
#include <cxxtls/cpptagdb.h>
#include <cxxtls/foreach.h>
#include <cxxtls/strtool.h>

#include <errno.h>
#include <string>
#include <algorithm>
#include <iomanip>

namespace cxxtls
{


std::string DirectoryViewer::app_name("DIRECTORY");

#ifdef _MSC_VER
#define SLASH '\\'
#else
#define SLASH '/'
#endif


bool DirectoryViewer::
is_special(size_t index)
{
   if(index >= names_.size())
     return  false;

   FileMode const &mode = status_[index].mode;

   return     mode.is_dir()
          ||  mode.is_link();
}


int
DirectoryViewer::
handle_event(CursorWindow::input_event const *e,
                   size_t index,
                   ViewerManager* vm)
  {
    if(e->type_ != input_event::FunctionKey &&
       e->type_ != input_event::DataKey
      )
    return 2;  // force a termination

    int edit_func = (*vm->window()).func[e->value_];

    switch(edit_func)
    {
      default:
        if(e->value_ == ('K' - '@'))
        {
          return 2;
        }
        
        break;

      case CursorWindow::func_enter:
        {
          view_dir(index, vm);
        }
        break;
        
      case CursorWindow::func_mark:
        goto mark_one_file;
        
        
      case CursorWindow::func_data:

        if(names_.size() <= index)
        {
          // sitting on an invalid position
        
          if( tolower(e->value_) != 'q' )
            break;
        }
        
        
        switch(e->value_)
        {

          case '\\': display_symbolic_link_file_target(index, vm);
                     break; 

          case 'q':  return 2;
          case 'Q':  return 2;
          case 'u':  user_names_ = !user_names_;
                     generate_row_text();
                     return 1;  // stuff has changed
                
          case 'i':  show_ids_ = !show_ids_;
                     generate_row_text();
                     return 1;  // stuff has changed
                
          case 'c':  return copy_file(index, vm);
          case '!':  return etags_first(vm);
          case '.':  return cpptags_first(vm);
          case '?':  return etags_all(vm);
          case '/':  return cpptags_all(vm);
          case '0':  return cpptagviewer(vm);
          case 'r':  return rename_file(index, vm);
          case 'R':  return rename_files(vm);
          case 'd':  return delete_file(index, vm);
          case 'D':  return delete_files(vm);
          case 'C':  return copy_files(vm);
          case 's':  // drop through
          case 'e':  {
                       FileName child(fullname_.dirname() + names_[index]);
                
                       child.convert_to_absolute_path();
                
                       if(child.is_dir())
                       {
                         FileName dirSearchPattern(child);  dirSearchPattern.convertToDirectorySearchPattern();

                         view_file_or_dir(dirSearchPattern, vm,true);
                       }
                       else
                       {
                          Viewer* oldie = vm->find_viewer(child);

                          if(oldie)
                          {
                            vm->activate(oldie);
                          }
                          else
                          {
                            Viewer* newbie = 0;

                            if(e->value_ == 's')
                              newbie = vm->open(child);
                            else
                              newbie = vm->edit(child);
                        
                            if(newbie)
                               vm->add(newbie, child);
                          }
                       }
                        
                     }
                     break;
          case '^':
                     {
               FileName parent(fullname_.dirname());   // remove the trailing '*'

               // now remove the trailing /

               if(   (parent.size() > 1)
                  && (   parent[parent.size()-1] == '/'
                      || parent[parent.size()-1] == '\\'
                     )
                 )
               {
                 if(parent.size() != 3 || parent[1] != ':')
                   parent.erase(parent.size()-1, 1);
               }

               
               parent = parent.dirname();  // remove the current directory name

               parent.convertToDirectorySearchPattern();
                
                       parent.convert_to_absolute_path();
                
                       view_file_or_dir(parent, vm,true);
                     }
                     break;
          case 'a':  return change_mode(index, vm);

          case 'm':
          mark_one_file:
                     {
                       // mark current file
                
                       marked_files_set::iterator scan = marks_.find(names_[index]);
                
                       if(scan == marks_.end())
                         marks_.insert(names_[index]);
                       else
                         marks_.erase(scan);
                        
                       return 0;
                     }
                     break;
                
          case 'M': return mark_files_by_pattern(vm);
        
          case 'L':
          case 'l':
          case 't':
                    {
                      sortCode_ = onName;

                      if(e->value_ == 'L')
                        sortCode_   = onSize;
                      else
                      if(e->value_ == 't')
                         sortCode_  = onTime;

                      read_directory();
                      generate_row_text();
                    }
                    return 1;

           case 'V':
             {
                static UserInfo user = UserInfo::get();

                FileName stvDir = user.home_dir_ + "/.tools_home/stv";

                if(!stvDir.is_dir())
                {
                    CursorWindow::Message s("Error:");

                    static std::string prefix("    ");

                    
                      s += "STV script directory not found";
                      s += prefix + stvDir;

                    s.popup(vm->window());

                }
                else
                {
                    FileName tmp(stvDir + "/*.sh");

                    FileName::sorted_names_t scripts;

                    tmp.find_matching(tmp.c_str(), &scripts);

                    if(scripts.empty())
                    {
                        CursorWindow::Message s("Error:");
                        
                        static std::string prefix("    ");
                        
                        
                          s += "STV script directory has no scripts";
                          s += prefix + stvDir;
                        
                        s.popup(vm->window());
                    }
                    else
                    {
                        CursorWindow::Selection s("Select a script:");
                        
                        FileName::sorted_names_t::const_iterator i;

                        for(i = scripts.begin(); i != scripts.end(); ++i)
                           s += *i;
                        
                        if(!s.popup(vm->window()))
                        {
                            std::string scriptname(stvDir + "/" + s.selection_);

                            char saved_dir[2048];

                            int err;

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

                            err = chdir( fullname_.dirname().c_str() );

                            Viewer *v;
                    
                            vm->add(  v = ScriptTableViewer::app(vm, scriptname), s.selection_ );

                            err = chdir(saved_dir);

                            (static_cast<ScriptTableViewer*>(v))->setDir(fullname_);

                            (void)(err);


                        }

                    }
                }
             }
             break;
                
                
        }

    }

    return 0;

  }


bool
DirectoryViewer::
is_marked(size_t index)
  {
    marked_files_set::iterator scan = marks_.find(names_[index]);

    if(scan == marks_.end())
      return false;

    return true;

  }

void
DirectoryViewer::
display_symbolic_link_file_target(size_t index, ViewerManager*vm)
{


    FileName f = fullname_.dirname() + names_[index];

    FileStatus st;

    bool error = false;

    if(f.file_stat(&st, true))
    {

       error = true;

    }

    error = error | !st.mode.is_link();

    if(error)
    {

        CursorWindow::Message d("Error -- file is not a symbolic link");
        
        d += "                                                        ";
        d += std::string(f);
        d += "";
        d += "";
        
        d.popup(vm->window());


       return;
    }


    static std::string indent("    ");


    CursorWindow::Message d("Link File Information");

    int mode = 0;

    d += "Link Target                                                      ";
    d += indent + f.readlink(&mode);
    d += "";


    FileMode fm(mode);

    d += "";
    d += "Link permissions (link itself not target):";

    d += indent + std::string(fm);

    d += "";
    d += "";

    d.popup(vm->window());
}

void
DirectoryViewer::
remove_item(size_t index)
    // remove the DirectoryViewer data structures associated with the
    // file name at the specified index.
  {
    marked_files_set::iterator scan = marks_.find(names_[index]);

    if(scan != marks_.end())
      marks_.erase(scan);

    strings_.erase( strings_.begin() + index );
    names_.erase( names_.begin() + index );
    status_.erase( status_.begin() + index);

    StreamableString ss;

    ss << "DIRED " << fullname_ << " [" << names_.size() << " files]";

    title_ = ss;

  }

DirectoryViewer::
DirectoryViewer(std::string const &fullname, bool show_user_names, bool show_ids)
  : marked_line_(0xffffffff),
    vp_width_(1000),
    user_names_(show_user_names),
    show_ids_(show_ids),
    sortCode_(onName)
  {
     fullname_ = fullname;

     fullname_.convert_to_absolute_path();

     title_ = std::string("DIRED ") + fullname;

     read_directory();

  }

struct FileNameComparator
{
    bool operator() (FileName const &left, FileName const &right) const
    {
       int cmp = StrTool::compareInsensitive(left, right);

       if(cmp < 0)
          return true;

       return false;
    }
};

static FileNameComparator nameComparator;

void
DirectoryViewer::
read_directory()
  {
     marks_.erase(marks_.begin(), marks_.end());
     strings_.erase(strings_.begin(), strings_.end());
     status_.erase(status_.begin(), status_.end());
     names_.erase(names_.begin(), names_.end());

     // find the files matching the specified directory
     // search pattern specified in 'fullname'

     file_name_list  l;
     int             count = FileName::find_matching(fullname_, &l);

     // create vectors of strings for faster access.  The names_
     // vector is raw text of the name, but the strings_ vector
     // contains the status info as well.

     names_.resize(count);

     std::copy(l.begin(), l.end(), names_.begin());

     // read the file status of all the files and store in a map
     // keyed to the basename of the file (actually, the keyed to the
     // strings found in the names_ array

     typedef std::map<FileName, FileStatus> StatMap;

     StatMap statMap;

     FileName dir = fullname_.dirname();

     {
       file_name_vector::iterator f, l;
       
       for(f = names_.begin(), l = names_.end(); f != l; ++f)
       {
         FileStatus fstat;
       
         FileName fullpath = dir + std::string("/") + *f;
       
         fullpath.file_stat(&fstat, true);

         statMap.insert(StatMap::value_type(*f, fstat)); 
       
       }
     }


     // sort the names of the files in the directory based on the sortCode_
     // parameter


     switch(sortCode_)
     {
       case onSize:
         // sort by the size of the files in descending order
         {
           typedef std::multimap<unsigned long long, FileName> Table;

           Table map;


           // read the size of each file and sort the names of the files
           // by the size thereof

           file_name_vector::iterator f, l;

           for(f = names_.begin(), l = names_.end(); f != l; ++f)
           {
             FileStatus fstat;

             StatMap::const_iterator search = statMap.find(*f);

             if(search != statMap.end())
             {
               fstat = search->second;
             }
             else
               fstat.size = 0;

             Table::value_type entry(fstat.size, *f);
             map.insert(entry);

           }

           //
           // copy the names back into the names_ vector but in an order
           // sorted by the size of the file
           //

           Table::const_iterator a, b;

           for(f=names_.begin(), a=map.begin(), b = map.end(); a != b; ++a, ++f)
           {
             *f = a->second;
           }

         }
         break;

       case onTime:
         // sort by the size of the files in descending order
         {
           typedef std::multimap<FileTime, FileName> Table;

           Table map;


           // read the size of each file and sort the names of the files
           // by the size thereof

           file_name_vector::iterator f, l;

           for(f = names_.begin(), l = names_.end(); f != l; ++f)
           {
             FileStatus fstat;

             StatMap::const_iterator search = statMap.find(*f);

             if(search != statMap.end())
             {
               fstat = search->second;
             }
             else
               fstat.time = FileTime(0); // null ptr to tm struct yields all 0's

             {
                 Table::value_type entry(fstat.time, *f);
                 map.insert(entry);
             }

           }

           //
           // copy the names back into the names_ vector but in an order
           // sorted by the size of the file
           //

           Table::const_iterator a, b;

           for(f=names_.begin(), a=map.begin(), b = map.end(); a != b; ++a, ++f)
           {
             *f = a->second;
           }

         }
         break;

       default:
         // by default, sort on the name of the files
         std::sort(names_.begin(), names_.end(), nameComparator);
         break;
     }


     {
       // move directories to the top of the list

       file_name_vector directories;
       file_name_vector normals;

       file_name_vector::iterator f, l;

       f=names_.begin();
       l = names_.end();

       while(f != l)
       {
         StatMap::const_iterator search = statMap.find(*f);

         if(search != statMap.end())
         {
           if(search->second.mode.is_dir())
           {
             directories.push_back(*f);
           }
           else
           {
             normals.push_back(*f);
           }
         }
         else
           normals.push_back(*f);


         ++f;
       }

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

       for(f=directories.begin(), l = directories.end(); f != l; ++f)
         names_.push_back(*f);

       for(f=normals.begin(), l = normals.end(); f != l; ++f)
         names_.push_back(*f);

     }

     // now, format the status info

     strings_.resize(count);
     status_.resize(count);

     file_name_vector::iterator first = names_.begin(),
                                last  = names_.end();

     file_status_vector::iterator out = status_.begin();


     string_vector::iterator sout = strings_.begin();

     while(first != last)
     {
        *sout++ = *first;

        FileStatus stat;

        StatMap::const_iterator search = statMap.find(*first++);

        if(search != statMap.end())
          stat = search->second;

        *out++ = stat;
        
     }

     // strings_ has only an abbreviate representation of the
     // useful data at this point
  }

void
DirectoryViewer::
generate_row_text()
  {

    StreamableString ss;

    ss << "DIRED " << fullname_ << " [" << names_.size() << " files]";

    title_ = ss;


    for(size_t row = 0, last=names_.size(); row != last; ++row)
      generate_row_text(row);

  }

void
DirectoryViewer::
generate_row_text(size_t index)
    //
    //
  {

    StreamableString ss;

    if(vp_width_ > 27)
    {
       ss << std::string(status_[index].mode) << " ";
    }

    if(vp_width_ > 51 )
    {
      ss << std::setw(12)
         << status_[index].size
         << " "
         ;
    }

    if(vp_width_ > 64 && show_ids_)
    {
      if(user_names_)
        ss << std::setw(12)
           << FileStatus::id2string(status_[index].owner_id)
           << " ";
      else
        ss << std::setw(12)
           << status_[index].owner_id
           << " ";
    }

    if(vp_width_ > 77 && show_ids_)
    {
      if(user_names_)
        ss << std::setw(12)
           << FileStatus::group2string(status_[index].group_id)
           << " ";
      else
        ss << std::setw(12)
           << status_[index].group_id
           << " ";
    }


    if(vp_width_ > 44 )
    {
      ss << status_[index].time.short_string() << " ";
    }

    ss << names_[index];


    strings_[index] =  ss;
  }


void
DirectoryViewer::
handle_resize(CursorWindow::row_col const &vp_size)
  {
    if(vp_width_ != vp_size.col_)
    {
      // the size has changed

      vp_width_ = vp_size.col_;

      generate_row_text();

    }
  }

int
DirectoryViewer::
copy_file(size_t index, ViewerManager* vm, FileName target_filename )
  {
    // allow the user to copy the file under the cursor.  Return 0 or 1
    // based on whether the target of the copy lies in the current directory.

    target_filename = target_filename.expand_tildes();

    if(index < names_.size())
    {
      FileName dirname  = fullname_.dirname();
      FileName filename = dirname + names_[index];

      if(filename.is_dir())
      {
        CursorWindow::Message m("Error");
        
        m += "Sorry, can not copy directories";
        m += "                                        ";
        m += "Press enter to continue";

        m.popup(vm->window());
        return 0;
        
      }
      else
      {
        FileName target;
        
        if(std::string(target_filename) == "")
        {
          CursorWindow::FileSelector  d("Copy file", fullname_ + "*", "");

          target = d.popup(vm->window(), 0);
        
          if(target.size() == 0)
            return 0;

          target = target.expand_tildes();
        
          if(!target.is_absolute_path())
          {
              target = dirname + target;
          }
        }
        else
          target = target_filename;

        
        if(target.is_dir())
        {
          target += '/';
          target += names_[index];
        }
        
        if(target.exists())
        {
        
          CursorWindow::Dialog e("Replace file? (Press Esc to cancel)");
        
          e += new CursorWindow::Dialog::Ok("name",
                                            std::string("Replace file ") + target
                                           );
          if(e.popup(vm->window()))
            return 0;
        }
        
        if(filename.copy(target))
        {
          // error occurred while copying
        
          CursorWindow::Message m("Error");
          m += "Error copying file: " + names_[index];
          m += "                to: " + target;
          m += "";
          m += "press enter to continue";
          m.popup(vm->window());
          return 0;
        
        }
        
        if(target.dirname() == dirname)
        {
          read_directory();
          generate_row_text();
        
          return 1;
        }
        
      }
    }
    return 0;

  }


int
DirectoryViewer::
etags_first(ViewerManager* vm)
{
  // prompt the user for the name of a symbol and then bring up an edit
  // session on the file defining that symbol.
  
  CursorWindow::Dialog d("Find symbol in ETAGS database");
     
  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol to find",
                                        "",
                                        40
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok", "ok");
                        
  if(d.popup(vm->window()))
    return 0;
  
  std::string symbol = d.element_value("symbol");
     
  if(symbol.size() == 0)
    return 0;

  // now, see if there is a tag with the given symbol name

  FileName     tagsfile;
  std::string  default_tags_path;

  EtagsDB* etags = vm->default_etags_db();

  if(etags && etags->ok())
  {
    std::string file;
    int         line;
    std::string matching_text;

    bool rv = etags->find_first(symbol, &file, &line, &matching_text);
  
    if(rv)
    {
      Viewer* oldie = vm->find_viewer(file);
  
      if(oldie)
      {
        oldie->set_row_col_hint(line-1,0);
        vm->activate(oldie);
      }
      else
      {
  
        Viewer* newbie = vm->edit(file);
  
        if(newbie)
        {
          newbie->set_row_col_hint(line-1,0);
  
          vm->vsplit(newbie, file);
  
        }
        else
          vm->active_viewport()->beep();
      }
  
    }
    
  }
  else
  {
    vm->active_viewport()->beep();
  }

  return 0;   
}

int
DirectoryViewer::
cpptags_first(ViewerManager* vm)
{

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

  if(!cpptags)
  {
    // error message will have been handled by ViewerManager code
    return 0;
  }
  
  
  // prompt the user for the name of a symbol and then bring up an edit
  // session on the file defining that symbol.
  
  CursorWindow::Dialog d("Find symbol in TAGPP.tagpp database");
     
  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol to find",
                                        "",
                                        40
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok", "ok");
                        
  if(d.popup(vm->window()))
    return 0;
  
  std::string symbol = d.element_value("symbol");
     
  if(symbol.size() == 0)
    return 0;

  // now, see if there is a tag with the given symbol name

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

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

    cpptags->findMatchingMembers(symbol, matches);

    if(!matches.empty())
    {
      // at least one match was found -- save the matches in the global list so that
      // we can pop the items off using the ^X , command in the editor or just the , command
      // in the directory viewer.

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

      vm->setFileLocations(locations);

      ViewerManager::FileLocation tmp;

      vm->popFileLocation(tmp);

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


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

  return 0;   
}


int
DirectoryViewer::
etags_all(ViewerManager* vm)
{
  // prompt the user for the name of a symbol and then let the user select
  // from all symbols matching that one in the etags database.
  
  CursorWindow::Dialog d("Find all matching symbols in ETAGS database");
     
  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol to find",
                                        "",
                                        40
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok", "ok");
                        
  if(d.popup(vm->window()))
    return 0;
  
  std::string symbol = d.element_value("symbol");
     
  if(symbol.size() == 0)
    return 0;

  // now, see if there is a tag with the given symbol name

  FileName     tagsfile;
  std::string  default_tags_path;

  EtagsDB* etags = vm->default_etags_db();

  if(etags && etags->ok())
  {
    std::string file;
    int         line;
    std::string matching_text;

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

      CursorWindow::Selection s("Symbols matching " + symbol);
    
      s += "";

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

         char buffer[40];

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

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

         s += tmp;

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

      }

      s += "";

      s += "Press Enter to continue";

      if(!s.popup(vm->window()))
      {
          size_t colon = s.selection_.find_first_of(':');

          if(colon >= s.selection_.size())
          {
             vm->active_viewport()->beep();
             return 0;
          }

          file = s.selection_.substr(0, colon);

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

          line = 0;

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

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

  return 0;   
}

int
DirectoryViewer::
cpptags_all(ViewerManager* vm)
{

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


  if(!cpptags)
  {
    // error message will have been handled by ViewerManager code
    return 0;
  }
  
  
  // prompt the user for the name of a symbol and then let the user select
  // from all symbols matching that one in the etags database.
  
  CursorWindow::Dialog d("Find all matching symbols in TAGPP.tagpp database");
     
  d += new CursorWindow::Dialog::String("symbol",
                                        "Symbol to find",
                                        "",
                                        40
                                       );
                                
  d += new CursorWindow::Dialog::Ok("ok", "ok");
                        
  if(d.popup(vm->window()))
    return 0;
  
  std::string symbol = d.element_value("symbol");
     
  if(symbol.size() == 0)
    return 0;


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


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


  if(!matches.empty())
  {
    std::string file;
    int         line;

    {

      CursorWindow::Selection s("Symbols matching " + symbol);
    
      s += "";

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

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

         char buffer[40];

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

         tmp += buffer;
         tmp += ' ';

         s += tmp;


      }

      s += "";

      s += "Press Enter to continue";

      if(!s.popup(vm->window()))
      {
          size_t colon = s.selection_.find_first_of(':');

          if(colon >= s.selection_.size())
          {
             vm->active_viewport()->beep();
             return 0;
          }

          file = s.selection_.substr(0, colon);

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

          line = 0;

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

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

  return 0;   
}

int
DirectoryViewer::
cpptagviewer(ViewerManager* vm)
{
    CursorWindow::Dialog m("Scan Subdirectories for C++ symbols?");
     
    m += new CursorWindow::Dialog::Ok("Begin Scan?","ok");

   if(m.popup(vm->window()))
       return 0;  // user aborted
    
    
    {
        std::string file = fullname_;

        if(file.size() > 2)
        {
           file = file.substr(0, file.size() -2); // remove trailing /*
        }

        file += SLASH;


        file += "!.cpptagdb";


        Viewer* oldie = vm->find_viewer(file);
        
        if(oldie)
        {
          vm->activate(oldie);
        }
        else
        {
        
          Viewer* newbie = vm->open(file);
        
          if(newbie)
          {
            vm->hsplit(newbie, file);
        
          }
          else
            vm->active_viewport()->beep();
        }
    }

  return 0;   
}


int
DirectoryViewer::
copy_files(ViewerManager*vm)
  {
    if(marks_.begin() == marks_.end())
      return 0;

    FileName dirname  = fullname_.dirname();

    FileName target;

    CursorWindow::FileSelector d("Copy files to a directory", fullname_ + "*", "");

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

    if(target.size() == 0)
      return 0;

    if(target[0] != '/' && target[1] != ':')
          {
            target = dirname + target;
          }

    target.convert_to_absolute_path();

    if(target.exists() && !target.is_dir())
    {

      CursorWindow::Message m("Error");

      m += "Sorry, target of a multifile copy operaton";
      m += "must be a directory.";
      m += "";
      m += "Press enter to continue";
                        
      m.popup(vm->window());
      return 0;
        
    }

    if(target[target.size()-1] != '/')
      target += '/';

    if(target == fullname_.dirname())
    {
        
      CursorWindow::Message m("Error");

      m += "Can't copy multiple files to the current directory";
      m += "";
      m += "Press enter to continue";
                        
      m.popup(vm->window());
      return 0;
        
    }

    marked_files_set::iterator first = marks_.begin(),
                               last  = marks_.end();
                        
                        
    while(first != last)
    {
      FileName source = fullname_.dirname() + *first;
      FileName dest   = target + *first;

      if(source.copy(dest))
      {
        int errtype = errno;

        std::string ErrorText("Error -- press Esc to cancel or Enter to continue");

        
        {
          char const *errtext = strerror(errtype);

          ErrorText="Copy Error (";
          ErrorText += errtext;
          ErrorText += " -- press Esc to cancel or Enter to continue";
        }


        
        CursorWindow::Dialog e(ErrorText.c_str());
        
        e += new CursorWindow::Dialog::Ok("name",
                                      "error copying " + (std::string&)(*first)
                                         );
                        
        if(e.popup(vm->window()))
          return 0;
        
      }

      ++first;

    }

    return 1;

  }


int
DirectoryViewer::
delete_file(size_t index, ViewerManager* vm, bool verify)
  {
    // allow the user to delete the file under the cursor.
    //
    // If the file was not actually deleted, return 1.  Otherwise return 0

    if(index < names_.size())
    {
      FileName filename = fullname_.dirname() + std::string("/") + names_[index];

      {
        if(verify)
        {
          CursorWindow::Dialog d("Delete file (press Esc to cancel)");
        
          d += new CursorWindow::Dialog::String("name",
                                            std::string("delete file ") + names_[index] + " ?",
                                            "    ",
                                            1
                                           );
                                
          if(d.popup(vm->window()))
            return 0;
        }
        
        FileName target = fullname_.dirname() + std::string("/") + names_[index];

        bool deleteFailed;

        if(target.is_dir())
          deleteFailed = target.rmdir();
        else
          deleteFailed = target.remove();


        if(deleteFailed)
        {
          CursorWindow::Message m(std::string("Error deleting file '") + names_[index] + std::string("'"));
        
          m += "Couldn't delete " + names_[index];
          m += "                                         ";
          m += "Press enter to continue";
                                
          m.popup(vm->window());
          return 1;
        }

        remove_item(index);
        return 0;

        
        
      }
    }
    return 0;

  }


int
DirectoryViewer::
change_mode(size_t index, ViewerManager* vm)
{
  using namespace std;

  // allow the user to edit file attributes of the file under the cursor.
  if(index < names_.size())
  {
    FileName filename = fullname_.dirname() + names_[index];

    string userPerms;
    string groupPerms;
    string worldPerms;

    FileMode extantMode = filename.file_mode();

    extantMode.unpackPermissions(userPerms, groupPerms, worldPerms);


    CursorWindow::Dialog d(string( "Change file " + names_[index] + " permissions" ) );

    d += new CursorWindow::Dialog::String("World",
                                          "World Permissions",
                                          worldPerms,
                                          4
                                         );

    d += new CursorWindow::Dialog::String("Group",
                                          "Group permissions",
                                          groupPerms,
                                          4
                                         );

    d += new CursorWindow::Dialog::String("User",
                                          "User permissions",
                                          userPerms,
                                          4
                                         );

    d.set_first_input_field("User");

    string group, world, user; // user inputs

    bool done=false;

    while(!done)
    {

      if(d.popup(vm->window()))
        return 0;
      
      group = d.element_value("Group"),
      world = d.element_value("World"),
      user  = d.element_value("User");
      
      string failure;  // name of failing perm field
      
      if(!extantMode.permStringValid(user))  failure="User";
      if(!extantMode.permStringValid(group)) failure="Group";
      if(!extantMode.permStringValid(world)) failure="World";
      
      if(!failure.empty())
      {
        CursorWindow::Message m("Error:");
      
        m += failure + " permission string is invalid!";
                              
        m.popup(vm->window());

        d.set_first_input_field(failure);

      }
      else
        done = true;

    }

    // all fields pass muster

    extantMode.packPermissions(user, group, world);
    
    if( filename.chmod(extantMode) != 0 )
    {
      CursorWindow::Message m("Error:");
    
      m += "chmod failed on " + names_[index];
                            
      m.popup(vm->window());
      return 0;
    }
      
    filename.file_stat(&status_[index]);
      
    generate_row_text(index);
    
    return 1;

  }

  return 0;

}


void
DirectoryViewer::
view_file_or_dir(std::string const &dir, ViewerManager* vm, bool is_dir)
  {

    Viewer *newbie = vm->find_viewer(dir);

    if(newbie)
    {
      vm->activate(newbie);
    }
    else
    if(is_dir)
    {

      newbie = new ListViewer(new DirectoryViewer(dir,
                                                user_names_,
                                                show_ids_),
                                                vm
                             );

      vm->add( newbie, dir);
    }
    else
    {
      newbie = vm->open(dir);

      if(newbie)
        vm->add(newbie, dir);
    }
        
  }

void
DirectoryViewer::
view_dir(size_t index, ViewerManager* vm)
  {
    if(names_.size() <= index)
      return;  // no target object

    // popup a new browser

    FileName dir = fullname_.dirname() + names_[index];

    if(names_[index] != std::string(".") && dir.is_dir())
    {

      dir.convertToDirectorySearchPattern();

      dir.convert_to_absolute_path();

      view_file_or_dir(dir,vm,true);

    }
    else
    {
      view_file_or_dir(dir, vm, false);
    }
        
  }

int
DirectoryViewer::
mark_files_by_pattern(ViewerManager* vm)
    // prompt the user for a file name pattern and mark files whose names
    // match that pattern.
  {
    CursorWindow::Dialog d("Mark multiple files");

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

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

    if(pattern == "")
      return 0;


    int count=0;

    {
      file_name_vector::iterator first = names_.begin(),
                                 last  = names_.end();
        
        
      while(first != last)
      {
        FileName const& curname = *first++;

        if(curname.matches(pattern))
        {
          ++count;  // count of changes, not marks
        
          marked_files_set::iterator scan = marks_.find(curname);
        
          if(scan != marks_.end())
            marks_.erase(scan);
          else
            marks_.insert(curname);
        }

      }
    }

    if(count == 0)
      return 0;

    return 1;

  }


int
DirectoryViewer::
delete_files(ViewerManager* vm)
  {
    if(marks_.begin() == marks_.end())
      return 0;

    {
      CursorWindow::Dialog d("Delete marked files (press Esc to cancel)");

      d += new CursorWindow::Dialog::String("name",
                                        std::string("delete files"),
                                        "    ",
                                        1
                                       );
                        
      if(d.popup(vm->window()))
        return 0;
    }


    size_t i,
           final = names_.size(),
           count = 0;

    for(i=0; i < final;)
    {
      if(marks_.find(names_[i]) != marks_.end())
      {
        // this item is marked

        if(delete_file(i, vm, false))
          ++i;  // file didn't get removed from the list and didn't get deleted
        
        ++count;
        
        // don't increment i, names_[i] was just deleted (supposedly)
        
        final = names_.size();
        
      }
      else
        ++i;  // skip this guy
    }

    if(count)
      return 1;

    return 0;
  }


Viewer*
DirectoryViewer::
app(ViewerManager*vm, std::string &fullname)
{
  if(fullname.size() == 0)
  {

    // do not use the viewer selector from here because it can not repaint the screen
    // in this context

    CursorWindow::Dialog d("File or Directory name");

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

    fullname = d.element_value("name");

    if(fullname == "")
      return 0;


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

    fullname = tmp;

  }

  DirectoryViewer *com = new DirectoryViewer(fullname);

  return new ListViewer(com,vm);
}


int
DirectoryViewer::
rename_file(size_t index, ViewerManager* vm, FileName target_filename)
  {
    // allow the user to rename the file under the cursor.  Return 0 or 1
    // based on whether the target of the rename lies in the current directory.

    if(index < names_.size())
    {
      static std::string sepcharString;

      static char sepchar= '/';

      if(sepcharString.empty())
         sepcharString += '/';


      FileName dirname  = fullname_.dirname();
      FileName filename = dirname + sepcharString + names_[index];

      {
        FileName target;
        
        if(target_filename == "")
        {
          CursorWindow::FileSelector d("Rename file:", fullname_ + "*", "");

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

          if(target.size() == 0)
            return 0;
        
          if(!target.is_absolute_path())
          {
              target = dirname + target;
          }
        }
        else
          target = target_filename;
        
        if(target.is_dir())
        {
          target += sepchar;
          target += names_[index];
        }
        
        if(target.exists())
        {
        
          CursorWindow::Dialog e("Replace file? (Press Esc to cancel)");
        
          e += new CursorWindow::Dialog::Ok("name",
                                            std::string("Replace file ") + target
                                           );
          if(e.popup(vm->window()))
            return 0;
        }
        
        if(target == filename)
        {
          return 0;  // nothing to do
        }
        
        if(filename.rename(target))
        {
          // error occurred while renaming
        
        
          CursorWindow::Message  e("Error");
        
          e += "Error renaming: " + names_[index];
                                
          e.popup(vm->window());
          return 0;
        
        }
        
        {
          // unmark the old name
        
          marked_files_set::iterator scan = marks_.find(target.basename());
        
          if(scan != marks_.end())
            marks_.erase(scan);
        
        }
        
        remove_item(index);
        
        if(target.dirname() == dirname)
        {
          read_directory();
          generate_row_text();
        
          return 1;
        }
        
      }
    }
    return 0;

  }


int
DirectoryViewer::
rename_files(ViewerManager*vm)
  {
    if(marks_.begin() == marks_.end())
      return 0;


    FileName target;


    CursorWindow::FileSelector d("Rename files to directory", fullname_ + "*", "");

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

    if(target.size() == 0)
      return 0;

    target.convert_to_absolute_path();

    if(target.exists() && !target.is_dir())
    {

      CursorWindow::Message e("Error");

      e += "Target of a multi-file rename must be a diretory";
      e += "";
      e += "Press enter to continue";
                        
      e.popup(vm->window());
      return 0;
        
    }

    if(target[target.size()-1] != '/')
      target += '/';

    if(target == fullname_.dirname())
    {
        
      CursorWindow::Message e("Error");

      e += "Can't rename multiple files to the current directory";
      e += "";
      e += "Press enter to continue";
                        
      e.popup(vm->window());
      return 0;
        
    }

    marked_files_set::iterator first = marks_.begin(),
                               last  = marks_.end();
                        
                        
    while(first != last)
    {
      FileName source = fullname_.dirname() + *first;
      FileName dest   = target + *first;

      if(source.rename(dest))
      {
        
        CursorWindow::Dialog e("Error -- press Esc to cancel or Enter to continue");
        
        e += new CursorWindow::Dialog::Ok("name",
                                      "error renaming " + (std::string&)(*first)
                                         );
                        
        if(e.popup(vm->window()))
          return 0;
        
      }

      ++first;

    }

    // Renamed files no longer exist in the directory display but may
    // exit in the directory -- under different names.  A re-read of
    // the directory display needs to be done.

    read_directory();

    generate_row_text();

    return 1;

  }


std::auto_ptr< std::list<std::string> >
DirectoryViewer::
help_text()
{
  std::list< std::string > *rv = new std::list<std::string>;

  rv->push_back("");
  rv->push_back("");
  rv->push_back("The DirectoryViewer");
  rv->push_back("");
  rv->push_back("(Use ^S to search)");
  rv->push_back("");
  rv->push_back("List the files in a directory and allow the user to issue");
  rv->push_back("commands that view them, edit them, discover information");
  rv->push_back("about them, etc.");
  rv->push_back("");
  rv->push_back("Here are the key bindings:");
  rv->push_back("");
  rv->push_back("  Enter -- view the file under the cursor");
  rv->push_back("  .  -- find a symbol in the TAGPP.tagpp database (see below)");
  rv->push_back("  /  -- find all matching symbols in TAGPP.tagpp database");
  rv->push_back("  !  -- find symbol in ETAGS database");
  rv->push_back("        Note:  the ETAGSPATH variable must be set for ETAGS commands to work.  ");
  rv->push_back("               See the editor's help for a description of it.");
  rv->push_back("  ?  -- find all matching symbols in ETAGS database");
  rv->push_back("  ^  -- view the parent directory");
  rv->push_back("  \\  -- display a symbolic link file's target");
  rv->push_back("  0  -- view symbols in this subdir tree");
  rv->push_back("  a  -- modify file attributes");
  rv->push_back("  c  -- copy the file under the cursor");
  rv->push_back("  C  -- copy marked files");
  rv->push_back("  d  -- delete the file under the cursor");
  rv->push_back("  D  -- delete marked files");
  rv->push_back("  e  -- edit the file/directory under the cursor");
  rv->push_back("  i  -- toggle display of user/group ids");
  rv->push_back("  l  -- re-read the directory and sort by name");
  rv->push_back("  L  -- re-read the directory and sort by SIZE");
  rv->push_back("  m  -- mark the current file");
  rv->push_back("  F5 -- function key 5 marks the current file");
  rv->push_back("  M  -- mark files matching a filename pattern");
  rv->push_back("  r  -- rename the current file");
  rv->push_back("  R  -- rename marked files");
  rv->push_back("  s  -- view the file without editing it");
  rv->push_back("  t  -- re-read the directory and sort by DATE");
  rv->push_back("  u  -- toggle user/group names display");
  rv->push_back("  V  -- Run a TableCommander script -- ");
  rv->push_back("        see ~/.tools_home/stv/*.sh for available scripts");
  rv->push_back("");
  rv->push_back("The TAGPP.tagpp database is a program symbol database created");
  rv->push_back("by the makeCppTags script found in the 'scripts' directory");
  rv->push_back("in this distribution.");


  return std::auto_ptr< std::list<std::string> >(rv);
}


bool DirectoryViewer::fetchAllLines(std::list< std::string > &output )
{

   CXXTLS_FOREACH(FileName const &cur, names_)
       output.push_back(cur);

   return true;
}


} // namespace cxxtls