v.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/file.h>
#include <cxxtls/ftp.h>
#include <cxxtls/cursorwindow.h>
#include <cxxtls/strtool.h>
#include <iostream>
#include <stdlib.h>
#include <portable_io.h>
#include <fstream>
#include <portable_strstream.h>

using namespace std;
using namespace cxxtls;

//@File
//
//

class DisplayList
  //

{
public:

  typedef list<string>     rep_t;
  typedef rep_t::iterator  iterator;

private:

  rep_t  rep_;
  size_t size_;

public:

  DisplayList()
  : size_(0)
  {
  }

  iterator begin() { return rep_.begin(); }
  iterator end()   { return rep_.end();   }

  DisplayList &operator += (string const &s)
  {
    ++size_;

    rep_.push_back(s);

    return *this;
  }

  size_t size() const { return size_; }


};


class ResizeHandler
  //
  //
: public CursorWindow::resize_handler
{

public:

  typedef DisplayList::iterator iterator;
  typedef CursorWindow::row_col row_col;

private:

  DisplayList         *  list_;
  iterator               top_;
  FileName               title_;
  int                    page_offset_;
  int                    lines_on_page_;  // real lines on this page

public:

  ResizeHandler(DisplayList *l, FileName title)
  : list_(l),
    top_(l->begin()),
    title_(title),
    page_offset_(0)
  {
  }

  void operator() (CursorWindow* w)
  {

     w->set_curpos(1,0);

     w->set_text_attribute(CursorWindow::normal);

     iterator scan = top_;

     int rows = w->size().row_ - 1;

     lines_on_page_ = 0;

     for(int i = 1; i < rows && scan != list_->end(); ++i, ++scan)
     {
       ++lines_on_page_;

       if(i == page_offset_ + 1)
       {
         w->set_text_attribute(CursorWindow::reversed);

         w->write(*scan);
         w->fill_to_eol();

         w->set_text_attribute(CursorWindow::normal);
       }
       else
       {
         w->write(*scan);
         w->fill_to_eol();
       }
     }

     w->fill_to_eos('_');

     w->set_curpos(0,0);

     w->set_text_attribute(CursorWindow::reversed);

     w->write(title_);
     w->fill_to_eol();

     char buffer[40];

     sprintf(buffer, "%lu", (unsigned long)(list_->size()) );

     int l = strlen(buffer);

     w->set_curpos(0, w->size().col_ - l);
     w->write(buffer);


     if(page_offset_ >= lines_on_page_)
     {
       // we have scrolled down past the bottom of the file
       // so the page_offset_ variable isn't valid --
       // set it to be the last valid line of the file, if
       // any and repaint that line as being marked

       if(lines_on_page_ == 0)
         page_offset_ = 0;
       else
       {

         page_offset_ = lines_on_page_-1;
        
         int i;
        
         for(i=0, scan = top_; i < lines_on_page_; ++i, ++scan)
         {
           if(i == page_offset_)
             break;
         }
        
         w->set_curpos(1 + page_offset_, 0);
         w->set_text_attribute(CursorWindow::reversed);
         w->write(*scan);
         w->fill_to_eol();
        
        
       }
     }

  }

  void pageup(CursorWindow* w)
  {

    int pagesize =  w->size().row_;

    pagesize -= 2;  // 1 for the header, and 1 just to keep context

    while(pagesize && top_ != list_->begin())
    {
      --pagesize;
      --top_;
    }

    page_offset_ = 0;

    (*this)(w);  // repaint after scrolling up


  }

  void pagedown(CursorWindow* w)
  {

    int pagesize =  w->size().row_;

    pagesize -= 2;  // 1 for the header, and 1 just to keep context

    iterator save = top_;

    while(pagesize && top_ != list_->end())
    {
      --pagesize;

      save = top_;

      ++top_;
    }

    if(top_ == list_->end()) //make sure we never really get to the
                             // end unless the list is empty
      top_ = save;

    page_offset_ = 0;

    (*this)(w);  // repaint after scrolling up


  }

  void lineup(CursorWindow*w)
  {
    if(page_offset_ == 0)
    {
      if(top_ == list_->begin())
        return;

      --top_;

      (*this)(w);
    }
    else
    {
      if(lines_on_page_ == 0)
        return;

      int offset = 0;

      iterator ip = top_;

      while(offset != page_offset_)
      {
        ++offset;
        ++ip;
      }

      // ip now points to the text of the current line
      // paint it in the normal color.

      w->set_text_attribute(CursorWindow::normal);
      w->set_curpos(1 + page_offset_, 0);
      w->write(*ip);
      w->fill_to_eol();


      //
      // now draw the previous line as highlightded
      //
      --ip;
      --page_offset_;

      w->set_text_attribute(CursorWindow::reversed);
      w->set_curpos(1 + page_offset_, 0);
      w->write(*ip);
      w->fill_to_eol();

      w->set_curpos(1 + page_offset_, 0);


    }

  }

  void linedown(CursorWindow*w)
  {
    if(lines_on_page_ < 2)
      return;

    if(page_offset_ >= lines_on_page_ -1)
    {
      iterator save = top_;

      if(top_ != list_->end())
        ++top_;

      if(top_ == list_->end())
        top_ = save;

      (*this)(w);

    }
    else
    {
      int offset = 0;

      iterator ip = top_;

      while(offset != page_offset_)
      {
        ++offset;
        ++ip;
      }

      // ip now points to the text of the current line
      // paint that line in the non-marked colors

      w->set_text_attribute(CursorWindow::normal);
      w->set_curpos(1 + page_offset_, 0);

      w->write(*ip);
      w->fill_to_eol();

      // now paint the next line in the marked color

      ++page_offset_;
      ++ip;

      w->set_text_attribute(CursorWindow::reversed);
      w->set_curpos(1 + page_offset_, 0);
      w->write(*ip);
      w->fill_to_eol();

      // put the cursor at the beginning of the line

      w->set_curpos(1 + page_offset_, 0);

    }

  }

};

static char binary_char='#';

static void readfile(FileName const &f, DisplayList &l)
{
    if(!f.exists())
    {
      cerr << "Error:   expected existing file or directory" << endl;
      exit(1);
    }

    fstream file;

    file.open(f.c_str(), ios::in);

    if(file.fail())
    {
      cerr << "error:  couldn't open " << f << endl;
      exit(1);
    }

    istreambuf_iterator<char> nc(file);
    istreambuf_iterator<char> lc;

    string line;

    while(nc != lc)
    {
      char c = *nc++;


      if(c == '\n')
      {
        l += StrTool::expand_tabs(line,0,binary_char);
        line.resize(0);
      }
      else
        line += c;
        
    }

    if(line.size())
      l += StrTool::expand_tabs(line,0,binary_char);


    file.close();
}


int main(int argc, char **argv)
{
  if(argc < 2)
  {
    cerr << "Error:   expected pathname" << endl;
    exit(1);
  }

  FileName f(argv[1]);


  DisplayList l;


  if(f[0] == 'f' &&
     f[1] == 't' &&
     f[2] == 'p' &&
     f[3] == ':' &&
     f[4] == '/' &&
     f[5] == '/'
    )
  {
    // I am expecting to see  ftp://user:pass@host/directory/file

    string rest(f.begin()+6, f.end());

    size_t slash = rest.find_first_of('/',0);

    if(slash >= rest.size())
    {
      cerr << "badly formatted ftp file name:  " << f << endl;
      cerr << endl;
      cerr << "expected ftp://user:pass@host/directory/file" << endl;
      exit(1);
    }

    string path(rest.begin() + slash, rest.end());

    string user_password_host(rest.begin(), rest.begin() + slash);

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

    if(colon >= user_password_host.size())
    {
      cerr << "badly formatted ftp file name:  " << f << endl;
      cerr << endl;
      cerr << "expected ftp://user:pass@host/directory/file" << endl;
      exit(1);
    }

    string user(user_password_host.begin(), user_password_host.begin() + colon);

    string password_host(user_password_host.begin() + colon + 1,
                         user_password_host.end()
                        );
                        
    size_t at = password_host.find_first_of('@');

    if(at >= password_host.size())
    {
      cerr << "badly formatted ftp file name:  " << f << endl;
      cerr << endl;
      cerr << "expected ftp://user:pass@host/directory/file" << endl;
      exit(1);
    }

    string password(password_host.begin(),
                    password_host.begin() + at
                   );
                
    string host(password_host.begin() + at + 1,
                password_host.end()
               );
                

    std::list<FTP::FileInfo> stats;

    std::list<FTP::FileInfo> target_status;

    bool force_directory_status=false;

    if(FTP::stat_matching(host,
                      user,
                      password,
                      path,
                      &target_status
                     )
      )
    {
       if(path.size() &&
          path[path.size()-1] == '/'
         )
       {
         force_directory_status=true;
        
       }
       else
       {
         cerr << "No such remote file as " << f << endl;
         exit(1);
       }

    }

    if(force_directory_status ||
       target_status.front().status_.mode.is_dir()
      )
    {
      FileName dirSearchPattern(path);  dirSearchPattern.convertToDirectorySearchPattern();

      FTP::stat_matching(host, user, password, dirSearchPattern, &stats);
                
      std::list<FTP::FileInfo>::iterator first=stats.begin(),
                                         last =stats.end();
                                
      while(first != last)
      {
         FTP::FileInfo &info = *first++;

         FileStatus& status =  info.status_;

         string line;

         line += status.mode;
         line += " ";
         line += status.time;
         line += " ";

         char buffer[40];

         sprintf(buffer, "%12lu", (unsigned long)status.size);

         line += buffer;
         line += " ";
         line += info.name_;

         l += line;

      }
    }
    else
    {
       // not a directory

      FileName tmp = FileName::mktemp();

      if(FTP::get(host, user, password, path, tmp))
      {
        cerr << "Error couldn't get remote file " << f << endl;
        exit(1);
      }

      readfile(tmp, l);

      tmp.remove();

    }



  }
  else
  if(f.is_dir())
  {
     FileName::sorted_names_t lf;

     FileName dirSearchPattern(f);  dirSearchPattern.convertToDirectorySearchPattern();

     f.find_matching(dirSearchPattern, &lf);


     f.convert_to_absolute_path();

     FileName::sorted_names_t::iterator f = lf.begin();
     FileName::sorted_names_t::iterator e = lf.end();

     while(f != e)
     {
       FileStatus status;

       f->file_stat(&status);

       string line;

       line += status.mode;
       line += " ";
       line += status.time;
       line += " ";

       char buffer[40];

       sprintf(buffer, "%12lu", (unsigned long)status.size);

       line += buffer;
       line += " ";
       line += *f;

       l += line;

       ++f;

     }


  }
  else
  {

    readfile(f, l);

  }

  CursorWindow w;

  w.open();

  ResizeHandler r(&l, f);

  r(&w);

  w.set_resize_handler(&r);

  for(;;)
  {
    CursorWindow::input_event e = w.read_input();

    if(e.type_ == CursorWindow::input_event::DataKey)
    {
      switch(e.value_)
      {
        case 'q':
        case 'Q':
        case 0x1b:
          return 0;
      }
    }
    else
    {
      switch(e.value_)
      {
         case CursorWindow::key_prior:
           r.pageup(&w);
           break;
        
         case CursorWindow::key_next:
           r.pagedown(&w);
           break;
        
         case CursorWindow::key_up:
           r.lineup(&w);
           break;
        
         case CursorWindow::key_down:
           r.linedown(&w);
           break;
        
        
        
      }

    }


  }




}