treeviewer.cxx

Go to the documentation of this file.

//
// Copyright 2011, 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.
//
// Warning:  not all files in this directory structure are covered by the
// same copyright.  Some of them are part of the GNU source distribution
// and you must obey the GPL copyright for those files.

#include <cxxtls/treeviewer.h>
#include <cxxtls/viewermanager.h>
#include <algorithm>

using namespace std;
//===================================================================================
//===================================================================================
//===================================================================================

namespace cxxtls
{

//-----------------------------------------------------------------------------------

int 
TreeViewerNode::
height() const
{
    int rv= 1;

    ChildrenList::const_iterator first = children_.begin(),
                                 last  = children_.end();

    while(first != last)
    {
        rv += (*first++).height();
    }

    return rv;
    
}

//-----------------------------------------------------------------------------------

void 
TreeViewerNode::
close(bool childrenToo)
{
    opened_ = false;

    if(childrenToo)
    {
        
        ChildrenList::iterator first = children_.begin(),
                               last  = children_.end();
        
        while(first != last)
        {
           (*first++).close(childrenToo);
        }
        
    }
}

//-----------------------------------------------------------------------------------

void 
TreeViewerNode::
open(bool childrenToo)
{
    opened_ = true;

    if(childrenToo)
    {
        ChildrenList::iterator first = children_.begin(),
                               last  = children_.end();
        
        while(first != last)
        {
           (*first++).open(childrenToo);
        }
    }

}

//-----------------------------------------------------------------------------------

void 
TreeViewerNode::
flatten(FlatForm &output, int depth)
{
    std::pair<TreeViewerNode*, int> me(this,depth);

    output.push_back(me);

    if(opened_)
    {
        ChildrenList::iterator first = children_.begin(),
                               last  = children_.end();
    
        while(first != last)
        {
           (*first++).flatten(output, depth+1);
        }
    }
}

//-----------------------------------------------------------------------------------

Viewer* 
TreeViewer::
app(ViewerManager*vm, std::string &fullname)
{
   TreeViewer *rv =new TreeViewer(vm);  

   rv->application_name_ = fullname;

   return rv;
}

//-----------------------------------------------------------------------------------
void
TreeViewer::
operator() ( CursorWindow::viewport * vp,
             int                      cmd
           )
{
    // paint the visible parts of the flattened form of the tree in the
    // specified viewport.

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

    if(flattenedNodes_.empty())
    {
       // first time through, initialize the display variables.

       nodes_.flatten(flattenedNodes_);

    }

    paintViewport(vp);

    positionCursor(vp);

}

//-----------------------------------------------------------------------------------
void
TreeViewer::
acknowledgeViewport( CursorWindow::viewport * vp)
{
    // adjust display variables to the available space

    CursorWindow::row_col size = vp->size();

    enum constants
    {
        TITLE_HEIGHT=1,   // row 0 is the title row
    };

    // compute the first node on which to display tree nodes

    treeStartRow_ = TITLE_HEIGHT;

    // compute the number of rows available for tree node to be displayed on

    displayRows_ = size.row_ - TITLE_HEIGHT;   

    // compute the number of nodes to actually display, given the 
    // space avaiable and the total number of nodes.

    displayNodes_= displayRows_;    // adjusted below

    int nodeCount = flattenedNodes_.size();

    if(nodeCount < displayNodes_)
    {
        displayNodes_ = nodeCount;
    }

    if(topNode_ + displayNodes_ >= nodeCount)
    {
      if(topNode_ >= nodeCount)
        topNode_ = nodeCount - 1;

        displayNodes_ = nodeCount - topNode_;
    }

    if(cursorNode_ < topNode_)   // first time through, topNode_ will be 0
    {
        cursorNode_ = topNode_;
    }
    else
    if(cursorNode_ >= topNode_ + displayNodes_)
    {
        // the cursor is off the bottom of the screen

        if(cursorNode_ >= nodeCount)
        {
          // how did this happen?

          if(nodeCount)
          {
             cursorNode_ = nodeCount - 1 ;
          }
          else
          {
             cursorNode_ = 0; // we have no nodes, 0 is as good as anything
          }
        }

        topNode_ = cursorNode_ - displayNodes_ / 2;

        if(topNode_ < 0)
        {
           topNode_ = 0;
        }

    }

    // At this point, all the display helper variables should be set
    // correctly.  That is the goal of this function.
    //
    // If the displayHeight_ is zero, then we shouldn't be painting anything.

}

//-----------------------------------------------------------------------------------
void
TreeViewer::
paintViewport( CursorWindow::viewport * vp)
{
    acknowledgeViewport(vp);
    
    paintTitle(vp);
    
    for(int i = 0; i < displayRows_; ++i)
    {
        // populate each row of the display area
    
        vp->set_curpos(i + treeStartRow_, 0);

        // vp->set_text_attribute(manager()->normal_att);

        vp->set_text_attribute(manager()->inactive_mark_att);

    
        if( i < displayNodes_)
        {
           // display an node from the flattened node list

           bool isCursor = false;

           if( i == cursorNode_ - topNode_)
           {
              isCursor = true;

              vp->set_text_attribute(active_ ? manager()->highlighted_att
                                             : manager()->normal_att
                                    );
           }

           paintNodeText(vp, topNode_+i, isCursor);
        
        }
        else
        {
            if(vp->origin().col_)
            {
               // if we are not exactly left aligned, eat 1 character as a border
        
               vp->write('|');
        
            }

            vp->fill_to_eol();
        }
    
    }


}

//-----------------------------------------------------------------------------------
void
TreeViewer::
paintNodeText(CursorWindow::viewport * vp, int nodeNumber, bool isCursor)
{

    if(vp->origin().col_)
    {
       // if we are not exactly left aligned, eat 1 character as a border

       vp->write('|');

    }
    
    int nodeCount = flattenedNodes_.size();

    if(nodeNumber < nodeCount)
    { 
        TreeViewerNode * node = flattenedNodes_[nodeNumber].first;
        int              depth= flattenedNodes_[nodeNumber].second;
        
        std::string const &name = node->name();
        
        vp->write(' ', depth * 4);  // 4 is length of "[-] "

        if(node->hasChildren())
        {
            if(node->opened())
                vp->write("[-] ");
            else
                vp->write("[+] ");
        }
        else
        {
            vp->write("[ ] ");
        }

        int savedTextAttribute = vp->text_attribute();


        if(node->highlighted() )
        {
          if(isCursor)
              vp->set_text_attribute( CursorWindow::active_mark_att );
          else
              vp->set_text_attribute( CursorWindow::normal_att );
        }


        *vp << name;

        vp->set_text_attribute(savedTextAttribute);

    }

    vp->fill_to_eol();


}


//-----------------------------------------------------------------------------------
void
TreeViewer::
paintTitle( CursorWindow::viewport * vp)
{
    vp->set_curpos(0,0);
    vp->set_text_attribute(active_ ?  manager()->active_title_att
                                   :  manager()->inactive_title_att
                          );
                          
    *vp << application_name();
  
    vp->fill_to_eol();

}


//-----------------------------------------------------------------------------------

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

      if(    e->type_ == CursorWindow::input_event::DataKey
         ||  e->type_ == CursorWindow::input_event::FunctionKey 
        )
      {

        // first, check to see if this is part 2 of a two part
        // command key sequence.  Part 1 is always ^X,

        if(keyKludge_)
        {
            keyKludge_ = false;

            switch(e->value_)
            {
                case 0x03: // ^X^C quit editing
                   return true;

                case 0x0b: // ^X^K quit editing

                   return true;  // when out of sessions, quit

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

            return false;
        }

        // ok, this is not part two a two part key sequence


         switch(e->value_)
         {
             case 0x18:  // ^X
             {
                keyKludge_ = true;
             }
             return false;

             case  'q': return true;
             case  'Q': return true;
             case 0x1b: return true; // escape key
             

             case  '+':                     toggle(vp);            positionCursor(vp); return false; 
             case  '=':                     toggle(vp);            positionCursor(vp); return false; 
             case  'o':                     toggleAll(vp);         positionCursor(vp); return false; 
             case  'O':                     toggleAll(vp);         positionCursor(vp); return false; 
             case  '<':                     findMyParent(vp);      positionCursor(vp); return false;
             case  '>':                     findNextParent(vp);    positionCursor(vp); return false;


             case CursorWindow::key_up:     moveUp(vp);            positionCursor(vp); return false;
             case CursorWindow::key_down:   moveDown(vp);          positionCursor(vp); return false;
             case CursorWindow::key_home:   pageTop(vp);           positionCursor(vp); return false;
             case CursorWindow::key_next:   pageDown(vp);          positionCursor(vp); return false;
             case CursorWindow::key_prior:  pageUp(vp);            positionCursor(vp); return false;
             case CursorWindow::key_end:    pageBottom(vp);        positionCursor(vp); return false;
             case 0x02:                     pageBottom(vp);        positionCursor(vp); return false; // ^B
             case 0x14:                     pageTop(vp);           positionCursor(vp); return false; // ^T
             case 0x13:                     findFirst(vp);         positionCursor(vp); return false; // ^S
             case 0x0e:                     findNext(vp);          positionCursor(vp); return false; // ^N

             default:




               if(!flattenedNodes_.empty() && flattenedNodes_[cursorNode_].first->info())
               {
                  // the current node does have user defined data -- let it handle the command key

                  positionCursor(vp);

                  return (*flattenedNodes_[cursorNode_].first->info())(manager(), vp, e->value_, rootDir_);

               }
               else
               if(   (e->value_ == '\r' || e->value_ == '\n') 
                  && !flattenedNodes_.empty() 
                 )
               {
                  // do nothing
               }
               else
               {
                  vp->beep();
               }

         }
      }
      else
      if(e->type_ == CursorWindow::input_event::ForceExitKey)
      {
          positionCursor(vp);

          return true; // don't ignore forced exits!
      }

   positionCursor(vp);

   return false; // in general, events do not terminate the viewer
}
//-----------------------------------------------------------------------------------

void 
TreeViewer::
moveUp(CursorWindow::viewport * vp)
{
   if(cursorNode_ == 0)
      return;

   if(cursorNode_ <= topNode_)
   {
      if(topNode_ == 0)
      {
        cursorNode_ = topNode_; // just to be sure
        return;
      }

      --topNode_;
      cursorNode_ = topNode_;

      if(topNode_ < 0)
        {
          topNode_ = 0;
          cursorNode_ = 0;
        }

      paintViewport(vp);
      return;
   }

   // if we get here, cursorNode_ > topNode_

   displayCurrentLine(vp,false);  // remove cursor

   --cursorNode_;

   displayCurrentLine(vp,true);     // display cursor in new position.


}

//-----------------------------------------------------------------------------------

void 
TreeViewer::
toggle(CursorWindow::viewport * vp)
{

    if(flattenedNodes_[cursorNode_].first->opened())
        close(vp);
    else
        open(vp);

}

//-----------------------------------------------------------------------------------

void 
TreeViewer::
toggleAll(CursorWindow::viewport * vp)
{
   TreeViewerNode * node= flattenedNodes_[cursorNode_].first;


    if(node->opened())
    {
       node->close();
    }
    else
    {
      node->open();
    }

   flattenedNodes_.clear();
   nodes_.flatten(flattenedNodes_);

   paintViewport(vp);



}

//-----------------------------------------------------------------------------------

void 
TreeViewer::
close(CursorWindow::viewport * vp)
{
   TreeViewerNode * node= flattenedNodes_[cursorNode_].first;

   if(node->opened())
   {
      node->close();  // close children trees as well
   }

   flattenedNodes_.clear();
   nodes_.flatten(flattenedNodes_);

   paintViewport(vp);


}

//-----------------------------------------------------------------------------------

void 
TreeViewer::
open(CursorWindow::viewport * vp)
{
   TreeViewerNode * node= flattenedNodes_[cursorNode_].first;


   if(!node->opened())
   {
      node->open(false);  // open doesn't open entire tree -- only
                          // first level deep
   }

   flattenedNodes_.clear();

   nodes_.flatten(flattenedNodes_);


   paintViewport(vp);


}

//-----------------------------------------------------------------------------------

void 
TreeViewer::
displayCurrentLine(CursorWindow::viewport * vp, bool highlighted)
{
   int offsetFromTopNode = cursorNode_ - topNode_;

   vp->set_curpos(offsetFromTopNode + treeStartRow_, 0);

   if(highlighted)
   {
       vp->set_text_attribute(active_ ? manager()->highlighted_att
                                      : manager()->normal_att
                             );
   }
   else
       vp->set_text_attribute(manager()->inactive_mark_att);

   paintNodeText(vp, cursorNode_);

}


//-----------------------------------------------------------------------------------
void 
TreeViewer::
moveDown(CursorWindow::viewport * vp)
{
   int nodeCount = flattenedNodes_.size();

   if(cursorNode_ > nodeCount-1)
       return;

   if(cursorNode_ == nodeCount-1)
   {
       // cursor sits on last valid line of the display
       // scroll the screen up

       if(cursorNode_ == topNode_)
          return; // can't scroll past top
       
       ++topNode_;
       --displayNodes_;

       if(displayNodes_ > displayRows_)
          displayNodes_ = displayRows_;

       paintViewport(vp);
       return;
   }

   int offset = cursorNode_ - topNode_;

   if(offset == displayNodes_-1)
   {
      // we are sitting on the last line on the screen in the middle of
      // the list -- scroll the page down

      ++topNode_;
      ++cursorNode_;
      paintViewport(vp);
      return;

   }

   // we are in the middle of the page in the middle of the list with the
   // end of the list way off the bottom

   displayCurrentLine(vp, false);
   ++cursorNode_;
   displayCurrentLine(vp, true);

}


//-----------------------------------------------------------------------------------
void 
TreeViewer::
pageTop(CursorWindow::viewport * vp)
{
   topNode_ = 0;
   cursorNode_ = 0;
   paintViewport(vp);
}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
pageBottom(CursorWindow::viewport * vp)
{
    topNode_ = flattenedNodes_.size() - 1;

    if(topNode_ < 0)
    {
       topNode_ = 0;
       cursorNode_ = 0;
       return;
    }

    // show only the last line of the list

    displayNodes_ = 1;
    cursorNode_ = topNode_;

    paintViewport(vp);

}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
pageDown(CursorWindow::viewport * vp)
{
    topNode_     += displayRows_;
    cursorNode_  += displayRows_;

    if(topNode_ >= int(flattenedNodes_.size())-1)
    {
       topNode_ = flattenedNodes_.size()-1;
    }

    if(cursorNode_ >= int(flattenedNodes_.size()) - 1)
    {
      cursorNode_ = flattenedNodes_.size()-1;
    }


    paintViewport(vp);

}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
pageUp(CursorWindow::viewport * vp)
{

    topNode_     -= displayRows_;
    cursorNode_  -= displayRows_;

    if(topNode_ < 0)
    {
        topNode_    = 0;
        cursorNode_ = 0;
    }


    paintViewport(vp);

}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
findFirst(CursorWindow::viewport * vp)
{
  CursorWindow::Dialog dialog("Find string");


  dialog += new CursorWindow::Dialog::String("mode",
                                             "(R)egexp, or (S)tring",
                                             (is_regex_ ? "R" : "S"),
                                             2
                                            );

  dialog += new CursorWindow::Dialog::String("text",
                                             "Search for",
                                             search_text_,
                                             40
                                            );

  dialog += new CursorWindow::Dialog::Ok("ok","");

  dialog.set_first_input_field("text");


  if( dialog.popup(vp->window()) )
    return;


  std::string match_words = dialog.element_value("mode");

  is_regex_    = false;

  if(   match_words.size() 
     && (match_words[0] == 'r' || match_words[0] == 'R')
    )
  {
    is_regex_ =  true;
  }

  std::string search_text = dialog.element_value("text");

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

  search_text_ = search_text;

  int    saved_line   = cursorNode_;

  displayCurrentLine(vp,false);  // remove cursor


  if(!findNextHelper(vp, false))
  {
    cursorNode_ = saved_line;
    vp->beep();
  }
  else
  {
    make_line_visible(vp);
  }

  displayCurrentLine(vp,true);  
  


}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
findNext(CursorWindow::viewport * vp)
{
  int    saved_line   = cursorNode_;

  displayCurrentLine(vp,false);  // remove cursor

  if(!findNextHelper(vp, true))
  {
    cursorNode_ = saved_line;
    vp->beep();
  }
  else
  {
    make_line_visible(vp);
  }

  displayCurrentLine(vp,true); // restore cursor
  

}

namespace
{
  struct CharCompare
  {

    bool operator() (char a, char b) const
    {
        {
          if( isupper(a) )
            a = tolower(a);
        
          if( isupper(b) )
            b = tolower(b);
        
          return a == b;
        }
        
        return a == b;
    }


  };

}



bool
TreeViewer::
findNextHelper(CursorWindow::viewport* vp, bool skipCurrentLine)
{
  // the caller must save/restore cursorNode_ as needed.


  if(is_regex_)
  {
    SimpleRegex *p = &regexp_;

    p->SimpleRegex::~SimpleRegex();  // destruct current regex

    new(&regexp_) SimpleRegex(search_text_,  "i" );


  }


  if(skipCurrentLine)
  {
      cursorNode_++;
  }


  while(cursorNode_ < int(flattenedNodes_.size()) )
  { // search all lines till eof

    std::string curline = flattenedNodes_[cursorNode_].first->name();

    size_t memberStart;

    if(curline.size() > (memberStart = curline.find_last_of(':')) )
    {
        ++memberStart;

        if(memberStart < curline.size())
        {
            curline = curline.substr( memberStart, curline.size() - memberStart );
        }
    }

    {

      std::string::iterator where;


      if(is_regex_)
      {

        int count = regexp_(curline, 0, curline.size());
        
        if(count > 0)
        {
          where = (curline.begin() + 0 + regexp_.matches()[0].offset);
        }
        else
          where = curline.end();
        
      }
      else
      {
        where = std::search(curline.begin() + 0,
                                                  curline.end(),
                                                  search_text_.begin(),
                                                  search_text_.end(),
                                                  CharCompare()
                                                 );
      }
                                        
      if(where != curline.end())
      {
           return true;
      }
    }

    ++cursorNode_;

  }


  return false;

}



//-----------------------------------------------------------------------------------

void
TreeViewer::make_line_visible(CursorWindow::viewport *vp)
{
    if(cursorNode_ - topNode_ >= displayNodes_)
    {
        // cursor is not visible.

        topNode_ = cursorNode_ - displayRows_ / 2;

        if(topNode_ < 0)
          topNode_ = 0;

        paintViewport(vp);
    }
}


//-----------------------------------------------------------------------------------
void 
TreeViewer::
findMyParent(CursorWindow::viewport * vp)
{

   int myDepth = flattenedNodes_[cursorNode_].second;

   while(    cursorNode_ > 0
         &&  flattenedNodes_[cursorNode_].second  >= myDepth
        )
   {
      --cursorNode_;
   }

   if(cursorNode_ < topNode_)
   {
      topNode_ = cursorNode_;
   }

   paintViewport(vp);



}

//-----------------------------------------------------------------------------------
void 
TreeViewer::
findNextParent(CursorWindow::viewport * vp)
{
   int myDepth = flattenedNodes_[cursorNode_].second;

   int maxNode = flattenedNodes_.size();

   while(    cursorNode_ < maxNode
         &&  flattenedNodes_[cursorNode_].second  >= myDepth
        )
   {
      ++cursorNode_;
   }

   if(cursorNode_ >= maxNode)
   {
     cursorNode_ = maxNode-1;
   }

   if(cursorNode_ >= topNode_ + displayNodes_)
   {
      topNode_ = cursorNode_;
   }

   paintViewport(vp);

}

//-----------------------------------------------------------------------------------

std::string const &
TreeViewer::
application_name() const
{
    return application_name_;
}

//-----------------------------------------------------------------------------------


TreeViewer::~TreeViewer()
{
}
//-----------------------------------------------------------------------------------

std::string TreeViewer::description() const 
{
   return "TreeViewer";
}

//-----------------------------------------------------------------------------------
void
TreeViewer::helpHeader(list<string> &help_text)
{
  help_text.push_back("TreeViewer help");
}


//-----------------------------------------------------------------------------------

void
TreeViewer::help()
{
  list<string> help_text;

  helpHeader(help_text); // derived class supply their own title and other info

  help_text.push_back("");
  help_text.push_back("");
  help_text.push_back("Command keys:");
  help_text.push_back("  enter     -- open the file defining the symbol under the cursor.");
  help_text.push_back("  +         -- open or close the current item (if it has children).");
  help_text.push_back("  o         -- completely open or close the entire current item's children  ");
  help_text.push_back("  <         -- move up to the current row's parent");
  help_text.push_back("  >         -- move down to the next parent higher than the current row");
  help_text.push_back("  ^T        -- move to the top of the tree");
  help_text.push_back("  ^B        -- move to the bottom of the tree");
  help_text.push_back("  ^S        -- search for a string string the tree");
  help_text.push_back("  ^N        -- search next");


  manager()->help_helper(help_text);
}

TreeViewerNodeInfo::
~TreeViewerNodeInfo()
{
}


void 
TreeViewer::
positionCursor(CursorWindow::viewport *vp)
{
    int col=0;

    if(cursorNode_ < int(flattenedNodes_.size()))
    {
       col = 4 * flattenedNodes_[cursorNode_].second;

       if(vp->origin().col_ != 0)
          ++col;
    }

    ++col;  // Step over one to account for the open bracket.  All rows
            // have something that looks like this one them:
            //
            //    [+] Name
            //     ^
            //    col

    vp->set_curpos((cursorNode_ - topNode_) + treeStartRow_, col);
}

}; // namespace cxxtls