viewer.cxx

Go to the documentation of this file.

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



#include <cxxtls/viewermanager.h>
#include <cxxtls/file.h>
#include <cxxtls/cursesinterface.h>
#include <cxxtls/strtool.h>
#include <cxxtls/foreach.h>

using namespace std;

namespace cxxtls
{

bool ListViewer::policies::is_special(size_t)
{
   return false; // default value for non-special lines
}

inline
int
ListViewer::
line_attribute(bool selected, size_t index, bool is_bottom)
  {
    int i=0;

    if(selected)                   i += 1;
    if(com_->is_marked(index))     i += 2;
    if(com_->is_special(index))    i += 4;

    switch(i)
    {
      case 1:   return active_ ? ViewerManager::highlighted_att
                               : ViewerManager::inactive_mark_att;
                               // selected but not marked
                        
      case 2:   return ViewerManager::inactive_mark_att; // marked but not selected

      case 3:   return active_ ? ViewerManager::active_mark_att
                               : ViewerManager::inactive_mark_att;

      case 4:   return is_bottom ? CursorWindow::bold_ul : CursorWindow::bold;
                // special, not selected, not marked

      case 5:   return active_ ? CursorWindow::rev_ul_bold
                               : CursorWindow::bold_ul;
                               // selected and special but not marked
                        
      case 6:   return ViewerManager::inactive_mark_att; // marked and special but not selected

      case 7:   return active_ ? ViewerManager::active_mark_att
                               : CursorWindow::bold_ul;

    }

    // case 0.

    return is_bottom ? ViewerManager::bottom_att : ViewerManager::normal_att;
  }

ListViewer::
policies::
~policies()
{
}

void
ListViewer::
policies::
handle_resize(CursorWindow::row_col const &)
{
  // by default, do nothing
}


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

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

  size_t  apps = com_->strings_.size();
  row_col vpsize  = vp->size();
  row_col vporigin= vp->origin();

  com_->handle_resize(vpsize);   // let policies object know what's
                                 // going on.

  int left = 0;

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


  // erase the viewport -- and underline the bottom line

  vp->set_curpos(0,0);
  vp->set_text_attribute(ViewerManager::normal_att);
  vp->fill_to_eos();

  if(left)
  {
    vp->set_text_attribute(CursorWindow::bold);

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

      using namespace CursesInterface;

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

    vp->set_text_attribute(ViewerManager::normal_att);
  }


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

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

  vp->set_curpos(0,left);

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

  {
    FileName tmp(com_->title_);

    *vp << tmp.shorten(vpsize.col_);
  }

  vp->fill_to_eol();

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

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


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

  // adjust cur_row_ to account for the possiblity of a smaller display
  // window than the last time we moved the cursor.
  {
      size_t avail = vpsize.row_ - row;
            
      if(cur_row_ - display_top_ >= avail)
      {
          display_top_ += avail/2;
      }
  }


  for(size_t  i = display_top_;
      row < vpsize.row_ && i < apps;
      ++i, ++row
     )
  {
    int att = line_attribute(i == cur_row_, i, row == vpsize.row_-1);

    vp->set_text_attribute(att);

    if(i == cur_row_)
    {
      // highlight the current row by making it reversed video

      vp->set_curpos(row, left);
      vp->fill_to_eol();

      // leave the text attributes as reversed
    }

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

    output_row_text(vp, i);

    if(att != ViewerManager::normal_att)
      vp->fill_to_eol();

  }

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

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

}

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

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


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

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

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

   row_col vporigin= vp->origin();

   int left = 0;

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

   vp->set_curpos(row,left);
   vp->set_text_attribute(line_attribute(false,
                                         cur_row_,
                                         (int)(cur_row_ - display_top_) == (size.row_ - first_row_ )-1
                                         ));

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();

   vp->set_curpos(row,left);

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

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

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

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

     case CursorWindow::func_up:

       if(com_->strings_.size() == 0)
         break;

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

       if(row == first_row_)
       {
         if(cur_row_ > 0)
         {
           --cur_row_;
           --display_top_;
           repaint(vp);
        
         }
       }
       else
       {
         --row;
         --cur_row_;
       }

       break;
     case CursorWindow::func_down:

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

       if(com_->strings_.size() == 0)
         break;

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

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

       display_top_ -= size.row_ - first_row_;

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

       row = first_row_;

       repaint(vp);

       break;

     case CursorWindow::func_next:

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

       display_top_ += size.row_ - first_row_;

       if( (int)(display_top_) >= (int)com_->strings_.size() )
         display_top_ = com_->strings_.size()-1;
        
       if( (int)(display_top_) < 0 )
         display_top_ = 0;
        
       cur_row_ = display_top_;

       row = first_row_;

       repaint(vp);

       break;

     case CursorWindow::func_find:

       find_string(cur_row_, manager_);

       if( (int)(cur_row_ - display_top_) >= size.row_ - first_row_)
       {
          display_top_ = cur_row_;

          row = first_row_;

          repaint(vp);
       }
       else
          row = first_row_ + cur_row_ - display_top_;

       break;

     case CursorWindow::func_findnxt:

       find_string(cur_row_);

       if( (int)(cur_row_ - display_top_) >= size.row_ - first_row_)
       {
          display_top_ = cur_row_;

          row = first_row_;

          repaint(vp);
       }
       else
          row = first_row_ + cur_row_ - display_top_;

       repaint(vp);

       break;


     default:

      // send all other events to the policies::handle_event member

      {
        int rv = com_->handle_event(e, cur_row_, manager_);
        
        switch(rv)
        {
          case 0:  break;
          case 1:
            {
              if(cur_row_ >= com_->strings_.size())
              {
                cur_row_ = com_->strings_.size() -1;
                
                if( (int)(cur_row_) < 0 )
                {
                  cur_row_ = 0;
                }

                if(display_top_ > cur_row_)
                  display_top_ = cur_row_;
                
              }
              vp->activate();
        
              row = first_row_ + (cur_row_ - display_top_);
            }
            break;
          case 2:
            return true;
        }
        
        if(manager_->active_viewer() !=  this)
        {
          // this viewer has been displaced from its visible positions,
          // so don't draw anything on the screen
        
          return false;  // we haven't died, we're just invisible
        }
        
      }
      break;

   }

   // now, highlight the appropriate line

   row_col saved_curpos = manager_->window()->curpos();

   vp->set_curpos(row,left);
   vp->set_text_attribute(line_attribute(true,
                                         cur_row_,
                                         (int)(cur_row_ - display_top_) == (size.row_ - first_row_ )-1
                                        ));

   *vp << "  ";

   output_row_text(vp, cur_row_);

   vp->fill_to_eol();


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

   if(vp != manager_->active_viewport())
   {
     manager_->window()->set_curpos(saved_curpos);
   }



   return false;
}

static string toLower(string inp)
{
    std::string::const_iterator first = inp.begin(),
                                last  = inp.end();

    string rv;
    
    
    while(first != last)
    {
       char cur = *first++;

       if(isupper(cur))
         cur = tolower(cur);

       rv += cur;
    }

    return rv;

}


int
ListViewer::
find_string(size_t index, ViewerManager*vm)
{
   CursorWindow::Dialog d("Find String");
        
   d += new CursorWindow::Dialog::String("name",
                                         "String to search for",
                                         "",
                                         15
                                        );
                                
   if(d.popup(vm->window()))
     return 0;
        
   search_string_ = toLower(d.element_value("name"));
        
   if(search_string_.size() == 0)
      return 0;

   return find_string(index-1); // may cause a wrap around since index is unsigned

}

int
ListViewer::
find_string(size_t index)
{
  if(index >= com_->strings_.size())
    index = 0;
  else
    ++index;

  while(index < com_->strings_.size())
  {
    string curLine = toLower( com_->strings_[index] );

    std::string::iterator match = std::search( curLine.begin(),
                                               curLine.end(),
                                               search_string_.begin(),
                                               search_string_.end()
                                             );
                                        
    if(match != curLine.end())
    {
      cur_row_ = index;
      return 1;             // display_top may not be on same page after return!
    }

   ++index;
                                        
  }

  return 0;

}

void Viewer::help()
{
  // by default, do nothing.
}

void
ListViewer::
help()
{
  // get the viewer's policy help info

  std::auto_ptr< std::list< std::string > > viewer_help(com_->help_text());

  manager_->help_helper(*viewer_help);

}

Viewer::paste_buffer_type*
Viewer::paste_buffer()
{
  fetchPasteBuffer();   // on systems that allow it (windows), this function
                        // overwrites the current paste buffer with the data
                        // in the system clipboard.

  return &manager_->paste_buffer_;
}

bool
Viewer::is_dirty() const
{
  return false;
}

#ifdef _MSC_VER

#include <windows.h>
#include <wincon.h>

#endif


void
Viewer::commitPasteBuffer() const
{
#ifdef _MSC_VER
  
  OpenClipboard(0);

  EmptyClipboard();

  string tmp;

  list<string>::iterator first = manager_->paste_buffer_.begin(),
                         last  = manager_->paste_buffer_.end();

  while(first != last)
  {
    string const &cur = *first++;

    tmp += cur;

    if(first != last)
      tmp += "\r\n";
  }

  char *buffer = (char*)(GlobalAlloc(GMEM_FIXED, 1 + tmp.size()));

  strcpy(buffer, tmp.c_str());

  SetClipboardData(CF_TEXT, buffer);

  CloseClipboard();

#else
#endif
}

void
Viewer::fetchPasteBuffer()
{
#ifdef _MSC_VER
 
  if(IsClipboardFormatAvailable(CF_TEXT)) 
  {
    OpenClipboard(0);

    char *p = reinterpret_cast<char*>(GetClipboardData(CF_TEXT));

    if(p)
    {
      manager_->paste_buffer_.clear();

      string curline;

      while(*p)
      {
        if(*p == '\r')
          ++p;
        else
        if(*p == '\n')
        {
          manager_->paste_buffer_.push_back(StrTool::expand_tabs(curline.c_str()));
          curline.resize(0);
          ++p;
        }
        else
        {
          curline += *p++;
        }
      }

      if(!curline.empty())
        manager_->paste_buffer_.push_back(StrTool::expand_tabs(curline.c_str()));

    }

    CloseClipboard();
  }
#else
#endif
}

bool Viewer::fetchAllLines(std::list<std::string> &output)
{
   return false;  // by default no viewer supports the fetchAllLinesFeature.
}

bool
ListViewer::
fetchAllLines(std::list<std::string> &output)
{
    if(com_.get())
       return com_.get()->fetchAllLines(output);
    else
       return false;
}

bool
ListViewer::
policies::
fetchAllLines(std::list<std::string> &output)
{
   CXXTLS_FOREACH(std::string const &cur, strings_)
      output.push_back(cur);

   return true;
}


} // namespace cxxtls