scripttableviewer.h

Go to the documentation of this file.

#ifndef SCRIPT_TABLE_VIEWER_HEADER_INCLUDED_p
#define SCRIPT_TABLE_VIEWER_HEADER_INCLUDED_p
//
// Copyright 2010, 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/tableeditor.h>
#include <map>

namespace cxxtls
{

class ScriptTableViewer
: public TableEditor
{
    std::string        scriptname_;
    std::string        fileError_;
    bool               keyKludge_;  // previous input key was ^X
    std::string        title_;      // displayed in top row of viewport

    std::vector<int>   invocationKeys_;  // keys that trigger script reinvocations 

    std::string        directory_; // current directory where script should run

    struct SessionInfo
    {

         std::map<std::string,std::string> options_;  

         CursorInfo  startCursorPosition_;

         std::string commandLine_;  





         std::vector< std::pair<size_t, size_t> > returnedCells_; 


         SessionInfo()
         :  startCursorPosition_(0,0,false)
         {
         }

         bool isPopup() const { return !returnedCells_.empty(); }


    };

    std::vector<SessionInfo> sessions_;  // Each level of script invocation is a session.
                                         // For example, the top level session is the invocation of the
                                         // script with parameters.  The table entries returned are selectable.
                                         // When a section of made from this table, session two is born.
                                         // When the user presses q from session 2, session 1 is restored.
                                         // 

    std::vector<std::pair<TableViewer, std::string> > prevScreenLayouts_;  
        // copies of the TableViewer contents, used to quickly
        // restore screen layouts after pages are exited.


    void handleReturnedCells();

public:

    ScriptTableViewer(ViewerManager *vm,
              std::string const &scriptName,
              std::string        directory=std::string()
             );
    
    bool ok() const { return fileError_.empty(); }
    
    std::string const &error() const { return fileError_; }
    
    virtual ~ScriptTableViewer();



    virtual std::string const &application_name() const; 
    virtual std::string description() const;             
    static Viewer* app(ViewerManager*vm, std::string &fullname);


    virtual bool handle_event( CursorWindow::input_event const * e,
                             CursorWindow::viewport          * vp
                           );

    virtual void help();  

    void populateTable(std::string const &scriptParms, CursorWindow::viewport *vp=0);

    void invokeCommand(CursorWindow::viewport *vp, int cmdKey);

    void restartSession(CursorWindow::viewport *vp);

    virtual void repaintTitle(CursorWindow::viewport *vp);

    void setDir(std::string const &dir) { directory_ = dir; } 


    bool fieldExecutable(size_t tableRow, size_t tableCol) const

    {
       if(    tableRow >= rows_.size()
          ||  tableCol >= cols_.size()
         )
            return false; // invalid table location

       return rows_[tableRow].executable_ && cols_[tableCol].executable_;
    }

    bool fieldExecutable(CursorInfo const &cur) const
    {
      return fieldExecutable(cur.row_, cur.col_);
    }

    bool showPopup(CursorWindow::viewport *vp,
                   std::string const &definition, 
                   std::vector< std::pair<std::string,std::string> > &userInputs
                  );
                                              
    void saveScreenLayout()
    {
       prevScreenLayouts_.push_back( std::pair<TableViewer,std::string>(*this,title_) );
    }

    void restoreSavedScreenLayout()
    {
       TableViewer &me = *this;
       
       me     = prevScreenLayouts_.back().first;
       title_ = prevScreenLayouts_.back().second;

       prevScreenLayouts_.pop_back();

    }

    void discardSavedScreenLayout()
    {
       prevScreenLayouts_.pop_back();
    }

};
} // namespace cxxtls
#endif