treeviewer.h

Go to the documentation of this file.

#ifndef TREE_VIEWER_HEADER_INCLUDED_p
#define TREE_VIEWER_HEADER_INCLUDED_p
//
// 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.

#include <cxxtls/viewer.h>
#include <cxxtls/simple_regex.h>
#include <cxxtls/file.h>

#include <list>
#include <vector>
#include <utility>  // to get std::pair

//============================================================================================
//============================================================================================
//============================================================================================

namespace cxxtls
{

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

    struct TreeViewerNodeInfo
    {
       virtual ~TreeViewerNodeInfo()=0;

       virtual bool operator() (ViewerManager*vm, CursorWindow::viewport *vp, int command, FileName const &) = 0;

    };

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

    class TreeViewerNode

    {
    public:
        typedef  std::list<TreeViewerNode> ChildrenList;                  
        typedef  std::vector<std::pair<TreeViewerNode*, int> > FlatForm;  

    private:

        ChildrenList children_;  // can have TreeViewerContains in them

        bool opened_;            // Indicates that the user has requested to see the 
                                 // child members displayed.  True by default.

        std::string name_;       // The text of this tree viewer node.

        TreeViewerNodeInfo *info_; // user defined extension

        bool highlighted_;          // display this node underlined

    public:

        TreeViewerNode(std::string const &name);
        TreeViewerNode();

        virtual ~TreeViewerNode(); 

        void setName(std::string const &n); 

        void adoptInfo(TreeViewerNodeInfo *p); 


        TreeViewerNodeInfo *info(); 


        TreeViewerNode& addChild(std::string const &name);

        ChildrenList const &children() const; 
        ChildrenList       &children();       

        bool hasChildren() const;        
        bool opened() const;             
        std::string const &name() const; 
        virtual int height() const;      


        void close(bool childrenToo=true);  
        void open(bool childrenToo=true);   

        void flatten(FlatForm &output, int depth=0);

        void setHighlighted();  

        bool highlighted() const { return highlighted_; }  
    };

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

    class TreeViewer
    : public Viewer
    {
        bool           active_;   
        TreeViewerNode nodes_;    

        TreeViewerNode::FlatForm flattenedNodes_;  

        FileName rootDir_; 



    public:
        std::string application_name_;
    private:

        int topNode_;        // top item in the flattenedNodes_ list to be displayed.
        int displayNodes_;   // amount of flattenedNodes_ to be displayed in the viewport
        int cursorNode_;     // node under the cursor

        int treeStartRow_;  // Top row in viewport for display of tree info.
                            // The titles etc occur above this row.
        int displayRows_;   // rows where displaying of tree data can occur.

        bool keyKludge_;    // ^X has been pressed

        bool is_regex_;            // search type flag
        std::string search_text_;  // most recent search string
        SimpleRegex regexp_;       // most recent regex search

    public:

        TreeViewerNode &topNode();   

        void flatten() { nodes_.flatten(flattenedNodes_); }

        virtual ~TreeViewer();

        void setApplicationName(std::string const &name);

        static Viewer* app(ViewerManager*vm, std::string &fullname);


        TreeViewer(ViewerManager* vm); 

        virtual void operator() ( CursorWindow::viewport *     vp,
                                  int                          cmd
                                );
        
        virtual bool handle_event( CursorWindow::input_event const * e,
                                   CursorWindow::viewport          * vp
                                 );
        
        virtual std::string const &application_name() const;
        
        virtual std::string description() const;

        virtual void help();


        void setRootDir(FileName const &dirname); 


        virtual void helpHeader(std::list<std::string> &helpText);  

    private:
        void acknowledgeViewport(CursorWindow::viewport * vp); // Set display height, etc
        void paintViewport(CursorWindow::viewport * vp);       // fill the viewport text
        void paintTitle(CursorWindow::viewport * vp);          // display window title
        void moveUp(CursorWindow::viewport * vp);              // cursor up
        void moveDown(CursorWindow::viewport * vp);            // cursor down
        void pageTop(CursorWindow::viewport * vp);             // move to top of list
        void pageBottom(CursorWindow::viewport * vp);          // move to bottom of list
        void pageDown(CursorWindow::viewport * vp);            // page down
        void pageUp(CursorWindow::viewport * vp);              // page up
        void findFirst(CursorWindow::viewport * vp);           // find string
        void findNext(CursorWindow::viewport * vp);            // find next instance of prev string
        bool findNextHelper(CursorWindow::viewport * vp, bool); // used by findfirst & next
        void make_line_visible(CursorWindow::viewport * vp);
        void displayCurrentLine(CursorWindow::viewport * vp, bool highlighted);
        void paintNodeText(CursorWindow::viewport * vp, int nodeNumber, bool isCursor=false);  
        void positionCursor(CursorWindow::viewport *vp); // for next user input

        void close(CursorWindow::viewport * vp);     // close the current item and redisplay the page
        void open(CursorWindow::viewport * vp);      // close the current item and redisplay the page
        void toggle(CursorWindow::viewport * vp);    // toggle open/close on current item
        void toggleAll(CursorWindow::viewport * vp); // toggle open/close on all items

        void findMyParent(CursorWindow::viewport * vp);     // search up for parent of curre item
        void findNextParent(CursorWindow::viewport * vp);   // search downfor next parent node, higher than current item

        
    };


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

inline 
TreeViewerNode::TreeViewerNode(std::string const &name)
: opened_(true)
, name_(name)
, info_(0)
, highlighted_(false)
{
}

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

inline 
TreeViewerNode::TreeViewerNode()
: opened_(true)
, info_(0)
, highlighted_(false)
{
}

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

inline 
void
TreeViewerNode::
setName(std::string const &name)
{
   name_ = name;
}

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

inline 
std::string const &
TreeViewerNode::
name() const
{
  return name_;
}

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

inline
TreeViewerNode&
TreeViewerNode::
addChild(std::string const &name)
{
   children_.push_back(name);
   return children_.back();
}
//----------------------------------------------------------------------------------------

inline
TreeViewerNode::ChildrenList const &
TreeViewerNode::
children() const 
{ 
    return children_; 
}
//----------------------------------------------------------------------------------------
inline
TreeViewerNode::ChildrenList &
TreeViewerNode::
children()
{ 
    return children_; 
}

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

inline
bool 
TreeViewerNode::
hasChildren() const 
{ 
    return !children_.empty(); 
}  

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

inline
bool 
TreeViewerNode::
opened() const 
{ 
    return opened_; 
}  

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

inline 
TreeViewer::
TreeViewer(ViewerManager* vm)
: Viewer(vm)
, active_(false)
, application_name_("TreeViewer")
, topNode_(0)
, displayNodes_(0)
, cursorNode_(0)
, treeStartRow_(0)
, displayRows_(0)
, keyKludge_(false)
, is_regex_(false)
{
}
//----------------------------------------------------------------------------------------


inline 
TreeViewerNode &
TreeViewer::
topNode() 
{ 
   return nodes_; 

} 

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


inline 
void
TreeViewerNode::
adoptInfo(TreeViewerNodeInfo *p) 
{ 
    delete info_;

    info_ = p;
} 

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


inline 
TreeViewerNode::
~TreeViewerNode()
{ 
    delete info_;

} 

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


inline 
TreeViewerNodeInfo *
TreeViewerNode::
info()
{ 
    return info_;
} 

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

inline
void 
TreeViewer::
setApplicationName(std::string const &name)
{
   application_name_ = name;
}

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

inline
void 
TreeViewer::
setRootDir(FileName const &name)
{
   rootDir_ = name;
}

//----------------------------------------------------------------------------------------
inline
void
TreeViewerNode::
setHighlighted()
{
   highlighted_ = true;
}



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

} // namespace cxxtls
#endif