tableviewer.h

Go to the documentation of this file.

#ifndef tableviewer_included_h_
#define tableviewer_included_h_
#include <cxxtls/viewer.h>

namespace cxxtls
{

class TableViewer
: public Viewer
{
public:

  TableViewer(ViewerManager*vm)
  :  Viewer(vm)
  ,  originRow_(0)         // ul corner row offset (zero based)
  ,  originCol_(0)         // ul corner col offset (zero based)
  ,  displayTitles_(false) // always display row and column titles.  See setDisplayTitles()
  ,  active_(false)        // not currently the active window
  ,  layoutDirty_(true)    // need to recompute layout
  ,  cursorRow_(-1)        // current cell row within layout_
  ,  cursorCol_(-1)        // current cell column within layout_
  ,  cursorDisplayed_(1)   // true if the current cursorRow_ and cursorCol_ are shown highlighted
  ,  displayOrigin_(0,0)   // for drawing during and after a paint (vp coords)
  ,  viewerManager_(vm)    // saved for the clear function
  ,  dataDirty_(0)         // field edits have not been saved
  ,  pageWidth_(0)         // world columns set painting process     (layout_ columns)
  ,  pageHeight_(0)        // world rows set by the painting process (layout_ rows)
  ,  mixed_case_(true)     // search parameter
  ,  is_regex_(false)      // search parameter
  ,  match_words_(false)   // search parameter
  ,  search_text_("")      // text to search for
  {
  }

  // WARNING:  Copies of this object are made, so don't leak memory!  Right now, now
  //           raw pointers that we own are kept in this class, if you add one make sure you 

  void triggerLayoutRecompute() { layoutDirty_ = true; }
  
  virtual ~TableViewer();

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

  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();                                 
  virtual bool is_dirty() const;                       

  struct ColumnInfo
  {
     std::string title_;
     size_t      width_;       // size hint, not actual value.  See TableViewer::colWidths_
     bool        leftBorder_;
     bool        bold_;
     bool        editable_;    // not used in table viewer, but derived classes can use it
     bool        executable_;  // ditto

     ColumnInfo()
     : title_("")
     , width_(0)
     , leftBorder_(false)
     , bold_(false)
     , editable_(true)
     , executable_(true)
     {
     }

     ColumnInfo(std::string const &title, size_t width, bool leftBorder)
     : title_(title)
     , width_(width)
     , leftBorder_(leftBorder)
     , bold_(false)
     , editable_(true)
     , executable_(true)
     {
     }

     ColumnInfo(std::string const &title, size_t width, bool leftBorder, bool bold, bool edit, bool executable)
     : title_(title)
     , width_(width)
     , leftBorder_(leftBorder)
     , bold_(bold)
     , editable_(edit)
     , executable_(executable)
     {
     }

  };

  struct RowInfo
  {
     std::string title_;
     size_t      height_;    // size hint, not actual value
     bool        bottomBorder_;
     bool        bold_;
     bool        editable_;   // not used in table viewer, but derived classes can use it
     bool        executable_;

     RowInfo()
     : title_("")
     , height_(0)
     , bottomBorder_(false)
     , bold_(false)
     , editable_(true)
     , executable_(true)
     {
     }

     RowInfo(std::string const &title, size_t height, bool bottomBorder)
     : title_(title)
     , height_(height)
     , bottomBorder_(bottomBorder)
     , bold_(false)
     , editable_(true)
     , executable_(true)
     {
     }

     RowInfo(std::string const &title, size_t height, bool bottomBorder, bool bold, bool edit, bool executable)
     : title_(title)
     , height_(height)
     , bottomBorder_(bottomBorder)
     , bold_(bold)
     , editable_(edit)
     , executable_(executable)
     {
     }

     void setRowTitleNumber(size_t row); // Set title_ to be a numeric string

  };

  struct CellInfo
  {
     std::vector< std::string > text_;  // one vector element for each row (usually 1)

     size_t worldRow_;       // imaginary coordinate system (bigger than screen)
     size_t worldColumn_;    // ditto

     size_t widestRow() const;  // returns max of string lengths in text_

  };


  struct FieldAttributes
  {
     bool bold_;
     bool underlined_;
     bool editable_;
     bool executable_;

     FieldAttributes(bool b=false, bool u=false, bool e=false, bool x=false)
     : bold_(b)
     , underlined_(u)
     , editable_(e)
     , executable_(e)
     {
     }

     template<class Iterator>
     static FieldAttributes
     skip(Iterator &first, Iterator const &last)

     {
        FieldAttributes fa;
     
        if(first == last || *first != '[')
        {
          return fa;
        }

        ++first;

        while(first != last && *first != ']' )
        {
           char c = *first++;

           switch(c)
           {
              case '!':  fa.bold_         = true; break;
              case 'x':  fa.executable_   = true; break;
              case 'e':  fa.editable_     = true; break;
              case '_':  fa.underlined_   = true; break;
           }
        }

        if(first != last)
          ++first; // skip trailing ]

        return fa;


     }


  };


  size_t rows() const { return rows_.size(); } 
  size_t cols() const { return cols_.size(); } 

  size_t originRow() const { return originRow_; } 
  size_t originCol() const { return originCol_; } 

  void setDisplayTitles(bool flag) { displayTitles_ = flag; }

  size_t longestRowTitle() const; 

  void setRowsAndColumns(size_t rows, size_t cols);

  size_t columnWidth(size_t column) const; 

  void setRowInfo(size_t row, std::string const &title, size_t height, bool border)
  {
     if(row < rows_.size())
     {
        layoutDirty_ = true;

        rows_[row].title_        = title;
        rows_[row].height_       = height;
        rows_[row].bottomBorder_ = border;
     }
  }

  void setRowInfo(size_t row, std::string const &title, size_t height, bool border, bool bold, bool edit)
  {
     if(row < rows_.size())
     {
        layoutDirty_ = true;

        rows_[row].title_        = title;
        rows_[row].height_       = height;
        rows_[row].bottomBorder_ = border;
        rows_[row].bold_         = bold;
        rows_[row].editable_     = edit;
     }
  }


  void setColInfo(size_t col, std::string const &title, size_t width, bool border)
  {
     if(col < cols_.size())
     {
        layoutDirty_ = true;

        cols_[col].title_ = title;
        cols_[col].width_ = width;
        cols_[col].leftBorder_ = border;
     }
  }

  void setColInfo(size_t col, std::string const &title, size_t width, bool border, bool bold, bool edit)
  {
     if(col < cols_.size())
     {
        layoutDirty_ = true;

        cols_[col].title_ = title;
        cols_[col].width_ = width;
        cols_[col].leftBorder_ = border;
        cols_[col].bold_       = bold;
        cols_[col].editable_   = edit;
     }
  }

  void addColumnHeader(std::string const &title, size_t width, bool border)
  {
      layoutDirty_ = true;

      cols_.push_back( ColumnInfo(title, width, border) );
  }

  void addColumnHeader(std::string const      &title, 
                       size_t                  width, 
                       FieldAttributes const  &a, 
                       bool                    border)
  {
      layoutDirty_ = true;

      cols_.push_back( ColumnInfo(title, width, border, a.bold_, a.editable_, a.executable_) );
  }


  void addColumnData(std::string const &text)
  {
      size_t rows = layout_.size();

      if(rows == 0)
      {
        addRow("",1,false);

        rows = 1;
      }

      std::vector<CellInfo> &row = layout_[rows-1];

      row.push_back(CellInfo());

      CellInfo &cell = row.back();

      cell.text_.push_back(text);  // 1 row in this cell
  }

  void addRow(std::string const &title, size_t height, bool bottomBorder, bool bold=false, bool editable=true, bool executable=true)
  {
     rows_.push_back( RowInfo(title, height, bottomBorder, bold, editable, executable ) );

     layout_.push_back(std::vector<CellInfo>());
  }

  RowInfo const &rowInfo(size_t row) const { return rows_[row]; }

  void setRowInfo(size_t row, RowInfo const &r) { rows_[row] = r; }



  CellInfo const *cellInfo(size_t row, size_t col) const;

  CellInfo *cellInfo(size_t row, size_t col);

   void setOrigin(size_t row, size_t col) { originRow_ = row; originCol_ = col; }

   virtual void setCursorInfo(CursorWindow::viewport *vp,
                              size_t worldRow, 
                              size_t worldCol, 
                              bool displayed=true);

   struct CursorInfo
   {
       size_t row_;
       size_t col_;
       bool   displayed_;

       CursorInfo(size_t r, size_t c, bool d)
       : row_(r)
       , col_(c)
       , displayed_(d)
       {
       }

   };

   CursorInfo cursorInfo() const { return CursorInfo(cursorRow_, cursorCol_, cursorDisplayed_); }

   void setCursorInfo(CursorWindow::viewport *vp, 
                      CursorInfo const &i
                     ) 
       


   { 
       setCursorInfo(vp, i.row_, i.col_, i.displayed_); 
   }

   void moveUp(CursorWindow::viewport *vp);      
                       
   void moveDown(CursorWindow::viewport *vp);    
                       
   void moveLeft(CursorWindow::viewport *vp);    
                       
   void moveRight(CursorWindow::viewport *vp);   
                       
   void pageUp(CursorWindow::viewport *vp);      
                       
   void pageDown(CursorWindow::viewport *vp);    
                       
   void pageBottom(CursorWindow::viewport *vp);  

   void pageTop(CursorWindow::viewport *vp);     
                       
   void pageRight(CursorWindow::viewport *vp);   
                       
   void pageLeft(CursorWindow::viewport *vp);    
                       
   void pageHome(CursorWindow::viewport *vp);    
                       
   void pageEnd(CursorWindow::viewport *vp);     
                       
   void clear();       

  void hideCursor(CursorWindow::viewport *vp);       

  void showCursor(CursorWindow::viewport *vp);       

  virtual void paintCursor(CursorWindow::viewport *); 

  void paintCell(CursorWindow::viewport *vp,
                 size_t vpRow,
                 size_t vpCol,
                 size_t tbRow,
                 size_t tbCol,
                 bool   highlight=false,
                 bool   editCursor=true

                );               

  void set_data_dirty(bool f) { dataDirty_ = f; }

  bool active() const { return active_; }

  bool mixed_case() const { return mixed_case_; }

  typedef std::vector< std::vector< CellInfo > > LayoutType;



private:



  size_t                    originRow_;
  size_t                    originCol_;

  bool                      displayTitles_;
  bool                      active_;  // currently active window?
  bool                      layoutDirty_; // need to recompute layout

  size_t                    cursorRow_;
  size_t                    cursorCol_;
  bool                      cursorDisplayed_;


  CursorWindow::row_col     displayOrigin_; // scr coords of origin table display 

  ViewerManager*            viewerManager_;  // we don't own this!

  CursorWindow::row_col     textInputPointer_;

  bool                      dataDirty_; // see is_dirty(), set_data_dirty()


  void recomputeLayout();  

protected:

  size_t                    pageWidth_;   // set by the painting proc
  size_t                    pageHeight_;

  std::vector<size_t>       colWidths_;     // computed widths


  LayoutType                layout_;  // a cell for each row and column

  std::vector<RowInfo>      rows_;  // titles, size hints etc
  std::vector<ColumnInfo>   cols_;

  // search dialog parameters
  //
  bool                      mixed_case_;     
  bool                      is_regex_;       
  bool                      match_words_;    
  std::string               search_text_;    




  virtual void paintField(CursorWindow::viewport *vp,
                          size_t          vpRow, 
                          size_t          vpCol, 
                          CellInfo const *cell, 
                          size_t          cellRow, 
                          size_t          vpColumns,
                          bool            editCursor
                         );

   void setTextInputPointer(size_t vpRow, size_t vpCol)
   {
       textInputPointer_.row_ = vpRow;
       textInputPointer_.col_ = vpCol;
   }

   void positionTextInputPointer(CursorWindow::viewport *vp);

   void forceRelayout() { layoutDirty_ = true; } 



    void insertRowAbove(CursorWindow::viewport *vp, RowInfo const &info); 

    void insertRowBelow(CursorWindow::viewport *vp, RowInfo const &info); 

    void deleteRow(CursorWindow::viewport *vp);

    void checkLayoutRecompute()
    {
        CursorInfo ci = cursorInfo();

        CellInfo *cell= cellInfo(ci.row_, ci.col_);

        if(!cell || cell->text_.empty())
          return;

        std::string text = cell->text_[0];
                        
        if(    (text.size() < colWidths_[ci.col_] / 2)
           ||  (text.size() > colWidths_[ci.col_] * 1.5)
          )
        {
          triggerLayoutRecompute(); 
        }
    }

    void findFirst(CursorWindow::viewport *vp);

    virtual bool findNext(CursorWindow::viewport *vp, bool first);

};
} // namespace cxxtls
#endif