tableviewer.cxx

Go to the documentation of this file.

//
// 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.
//
// 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/tableviewer.h>
#include <cxxtls/viewermanager.h>
#include <algorithm>
#include <cxxtls/simple_regex.h>

#include <ctype.h>

using namespace std;

namespace cxxtls
{

TableViewer::~TableViewer()
{
}

void TableViewer::repaintTitle( 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();

}

void TableViewer::operator() ( CursorWindow::viewport *     vp,
                               int                          cmd
                             )
{
  // WARNING:  do not save vp -- it gets deleted regularly!
  // repaint the current visible page

  // Determine if the page is active or inactive based on the
  // cmd variable passed to us.

  hideCursor(vp);


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

  // Repaint the title line in text attributes just determined


  repaintTitle(vp);


  // Set up to recompute the viewport dimensions and the needs of
  // the table.


  pageWidth_  = 0;
  pageHeight_ = 0;

  recomputeLayout(); // if dirty...

  row_col size    = vp->size();


  int row;

  vp->set_text_attribute(manager_->normal_att);


  displayOrigin_.row_ = 2; // 1 for app name and 1 for column headers
  displayOrigin_.col_ = longestRowTitle();


   pageWidth_ = 0;

   size_t gutterWidth = 1;


  //  Handle the display of column headers  (and also calculate
  //  the widthds of the columns in the actual table).

   // first, find out how wide the columns are and paint the titles
   {
       size_t col;

       colWidths_.resize(0);

       for(col=0; col < cols_.size(); ++col)
       {
          // handle all worldColumns

          size_t colWidth = columnWidth(col);
    
          colWidths_.push_back(colWidth);
       }

       size_t paintColumn = displayOrigin_.col_;

       vp->set_text_attribute(CursorWindow::bottom_att);
       vp->set_curpos(displayOrigin_.row_-1,0);
       vp->fill_to_eol();

       vp->set_curpos(displayOrigin_.row_-1, paintColumn);


       for(col=0; col < cols_.size() - originCol(); ++col)
       {
           size_t workingCol = originCol() + col;

           size_t colWidth = colWidths_[workingCol];


           vp->set_curpos(displayOrigin_.row_-1, paintColumn + gutterWidth);


           *vp << cols_[workingCol].title_;

           if(paintColumn + colWidth + gutterWidth > size_t(size.col_))
           {
             // once a column has gone past the end of the current page
             // break out of this loop.  Keep the offending column and let
             // clipping handle the display issues, but keep this column
             // otherwise we'll never see any part of a big column...

             ++col; // col becomes page width below, so
                    // we need it to be 1 more than the current
                    // column

             break;
           }

           paintColumn +=  colWidth + gutterWidth;

       }

       pageWidth_ = col;  // saved in TableViewer class for use by paintCursor

       vp->fill_to_eol();

   }
   

  // Now paint the data in the rows.

  vp->set_text_attribute(manager_->normal_att);


  size_t lastPaintedRow=1000;

  // in the following algorithm, "row" refers to the virtual layout_ world, not the screen.

  pageHeight_ = 0;

  for(row=0; row < (size.row_ - displayOrigin_.row_); ++row)
  {
      size_t workingRow = originRow() + row;

      if(workingRow >= layout_.size() || workingRow >= rows() )
          break;

      ++pageHeight_;  // in layout_ rows

      LayoutType::value_type &curRow = layout_[workingRow];

      vp->set_curpos(row+displayOrigin_.row_, 0);

      vp->set_text_attribute(manager_->normal_att);

      *vp << rows_[workingRow].title_;

      {
         row_col curpos = vp->curpos();

         int colDelta = displayOrigin_.col_ - curpos.col_;

         for(int i = 0; i < colDelta; ++i)
         {
           *vp << " ";
         }

      }

      if(curRow.size())
      {
         for(size_t col = 0; col < pageWidth_; ++col)
         {
             size_t workingCol = originCol() + col;

             int worldCol = curRow[workingCol].worldColumn_ -
                            curRow[originCol()].worldColumn_;
    
             if(worldCol < size.col_)
             {
                 paintCell(vp,
                           lastPaintedRow = row+displayOrigin_.row_,
                           worldCol+displayOrigin_.col_,
                           workingRow,
                           workingCol,
                           false,  // not highlighed
                           false   // don't position cursor to edit colum
                          );
    
             }
         }
      }

      vp->set_text_attribute(manager_->normal_att);

      vp->fill_to_eol();

  }

  // clear out any text appearing after the last row.

  vp->set_text_attribute(manager_->normal_att);

  while(lastPaintedRow < size_t(size.row_))
  {
    ++lastPaintedRow;
    vp->set_curpos(lastPaintedRow, 0);
    vp->fill_to_eol();
  }

 //
 //  ADJUST CURSOR POSITION TO FIT IN THE PAINTED REGION
 //

 //  setCursorInfo(vp, originRow(), originCol(), active_);

  cursorDisplayed_ = active_;

  if(cursorRow_ > rows())
    cursorRow_ = originRow();

  if(cursorCol_ > cols())
    cursorCol_ = originCol();

  if(pageHeight_ && (cursorRow_ >= originRow() + pageHeight_) )
  {
      size_t lastRow = originRow() + (pageHeight_ -1);

      if(lastRow > 1)
      {
         cursorRow_ = lastRow-1;
      }
      else
      {
         cursorRow_ = 0;
      }


  }

  if(pageWidth_ && (cursorCol_ >= originCol() + pageWidth_) )
  {
      // note that it is possible for the last column to be
      // only partially displayed.

      size_t lastCol = originCol() + (pageWidth_ -1);

      if(lastCol > 1)
      {
         cursorCol_ = lastCol-1;
      }
      else
      {
         cursorCol_ = 0;
      }


  }

  if(cursorCol_ < originCol())
     cursorCol_ = originCol();

  if(cursorRow_ < originRow())
     cursorRow_ = originRow();

  if(cursorDisplayed_)
    showCursor(vp);


}


bool TableViewer::handle_event( CursorWindow::input_event const * e,
                                CursorWindow::viewport          * vp
                              )
{
  vp = vp;
  
  if(e)
  {
      if(    e->type_ == CursorWindow::input_event::DataKey
         ||  e->type_ == CursorWindow::input_event::FunctionKey 
        )
      {
         static RowInfo bi; // blank info

         switch(e->value_)
         {
             case 'q': return true;
             case 'Q': return true;

             case CursorWindow::key_up:     moveUp(vp);            return false;
             case CursorWindow::key_down:   moveDown(vp);          return false;
             case CursorWindow::key_left:   moveLeft(vp);          return false;
             case CursorWindow::key_right:  moveRight(vp);         return false;
             case 0x09:                     pageRight(vp);         return false; // tab
             case CursorWindow::key_btab:   pageLeft(vp);          return false;
             case CursorWindow::key_home:   pageHome(vp);          return false;
             case CursorWindow::key_next:   pageDown(vp);          return false;
             case CursorWindow::key_prior:  pageUp(vp);            return false;
             case CursorWindow::key_end:    pageEnd(vp);           return false;
             case 0x02:                     pageBottom(vp);        return false; // ^B
             case 0x14:                     pageTop(vp);           return false; // ^T
             case 0x13:                     findFirst(vp);         return false; // ^S
             case 0x0e:                     findNext(vp,false);    return false; // ^N

             case CursorWindow::key_f9:     
             {

                 CursorInfo tmp = cursorInfo();

                 insertRowAbove(vp,bi); 


                 (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
                 setCursorInfo(vp, tmp);
             }
             return false;
             case CursorWindow::key_f11:    
             {
                 CursorInfo tmp = cursorInfo();

                 insertRowBelow(vp,bi); 
                 (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
                 setCursorInfo(vp, tmp);
             }
             return false;
             case CursorWindow::key_f8:    
             {
                 CursorInfo tmp = cursorInfo();

                 deleteRow(vp); 
                 (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
                 setCursorInfo(vp, tmp);
             }
             return false;


         }
      }
  }

  return true;  // any key terminates input at this time
}


string const &TableViewer::application_name() const
{
     static string empty("some table");

     return empty;
}

string TableViewer::description() const
{
   return "the table viewer base class";
}


void TableViewer::help()
{
}



bool TableViewer::is_dirty() const
{
    return dataDirty_;
}


size_t TableViewer::longestRowTitle() const
{
    size_t rv = 0;

    vector<RowInfo>::const_iterator first = rows_.begin(), last = rows_.end();

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

        size_t length = cur.title_.size();

        if(length > rv)
          rv = length;

    }

    return rv;
}

size_t TableViewer::CellInfo::widestRow() const
{
  vector<string>::const_iterator first = text_.begin(), last = text_.end();

  size_t rv = 0;

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

    size_t length = cur.size();

    if(length > rv)
      rv = length;

  }

  return rv;
}
void TableViewer::setRowsAndColumns(size_t rows, size_t cols)
{
    layout_.resize(rows);

    for(size_t i = 0; i  < layout_.size(); ++i)
    {
        layout_.resize(cols); // resize the cols to match the request.
    }

    rows_.resize(rows);
    cols_.resize(cols);

    recomputeLayout(); // regenerate world coords in all rows and cols


}
size_t TableViewer::columnWidth(size_t col) const
{
    size_t rv = 0;

    if(cols_.size() > col)
    {
       rv = cols_[col].width_;
    }

    LayoutType::const_iterator firstRow = layout_.begin(), lastRow = layout_.end();

    while(firstRow != lastRow)
    {
       LayoutType::value_type const &curRow = *firstRow++;

       if(curRow.size() > col)
       {
          // this row has the specfied column

          size_t width = curRow[col].widestRow(); // in the multi-row cell

          if(width > rv)
            rv = width;

       }
    }

    return rv;

}
TableViewer::CellInfo const *
TableViewer::cellInfo(size_t row, size_t col) const
{
   return const_cast<TableViewer*>(this)->cellInfo(row,col);
}

TableViewer::CellInfo *
TableViewer::cellInfo(size_t row, size_t col) 
{
    if(row < rows())
        if(col < cols_.size())
        {
           // this row and column should exist -- but due to lazy
           // evaluation, mabye it does not -- make sure that the 
           // cell does before returning its addres.

           while(layout_.size() <= row)
           {
               layout_.push_back( LayoutType::value_type() ); // create rows  
           }

           while(layout_[row].size() <= col)
           {
             layout_[row].push_back( LayoutType::value_type::value_type() );
           }

           return &layout_[row][col];
        }

    return 0;
   
}

void TableViewer::recomputeLayout()
{
   // the data for positions in the computed layout have to be adjusted to account
   // for titles and other adjustments before positioning the real cursor.


   if(!layoutDirty_)
      return;

   layoutDirty_ = false;

   LayoutType::iterator firstRow = layout_.begin(), lastRow = layout_.end();

   vector<size_t> colWidths_;

   // first, find out how wide the columns are

   for(size_t col=0; col < cols_.size(); ++col)
   {
      size_t colWidth = columnWidth(col);

      colWidths_.push_back(colWidth);
   }

   // next, assign virtual world row/col coords for each

   size_t worldY = 0;  // assume no titles or other issues of interest

   while(firstRow != lastRow)
   {
      LayoutType::value_type &curRow = *firstRow++;

      size_t worldX = 0;  // assume no titles

      curRow.resize( cols_.size() );

      LayoutType::value_type::iterator firstCol = curRow.begin();
      LayoutType::value_type::iterator lastCol = curRow.end();

      vector<size_t>::const_iterator widthPtr = colWidths_.begin(), widthEnd = colWidths_.end();

      size_t tallestCellHeight=1;

      while(firstCol != lastCol && widthPtr != widthEnd )
      {
         CellInfo &cell = *firstCol++;

         ++worldX; // skip the | or space gutter before each row

         cell.worldColumn_ = worldX;
         cell.worldRow_    = worldY;

         worldX += *widthPtr++;

         size_t cellHeight = cell.text_.size();

         if(cellHeight > tallestCellHeight)
             tallestCellHeight = cellHeight;

      }

      worldY +=  tallestCellHeight;

   }
}

void TableViewer::setCursorInfo(CursorWindow::viewport *vp,
                                size_t r, 
                                size_t c, 
                                bool v)
{
   if(r != cursorRow_ || c != cursorCol_ )
   {
       hideCursor(vp);  // marks it as un-displayed if it already is
   }

   cursorRow_       = r;
   cursorCol_       = c;
   cursorDisplayed_ = v;

   if(v)
        showCursor(vp);
}

void TableViewer::hideCursor(CursorWindow::viewport *vp)
{
    cursorDisplayed_ = false;

    paintCursor(vp);

}
void TableViewer::showCursor(CursorWindow::viewport *vp)
{
    cursorDisplayed_ = true;
    paintCursor(vp);
   
}
void TableViewer::paintCursor(CursorWindow::viewport *vp)
{
    // redraw the cursor on the specified viewport.

    if(vp)
    {

       size_t cursorRowDelta = cursorRow_ - originRow();
       size_t cursorColDelta = cursorCol_ - originCol();

       if(cursorRowDelta < pageHeight_ && cursorColDelta < pageWidth_)
       {
          // ok, the cursor is visible on the screen

          size_t screenRowDelta = 0;

          size_t screenColDelta = 0;

          if(layout_.size() > cursorRow_ && layout_[cursorRow_].size() > cursorCol_)
          {
              CellInfo const &cursorCell = layout_[cursorRow_][cursorCol_];
              
              screenRowDelta = cursorCell.worldRow_ -
                               layout_[originRow()][originCol()].worldRow_;
              
              screenColDelta = cursorCell.worldColumn_ -
                               layout_[originRow()][originCol()].worldColumn_;
              
          }

          int screenRow = screenRowDelta + displayOrigin_.row_;
          int screenCol = screenColDelta + displayOrigin_.col_;

          setTextInputPointer(screenRow, screenCol+1); // one for the gutter

          paintCell(vp,
                    screenRow, 
                    screenCol, 
                    cursorRow_, 
                    cursorCol_, 
                    cursorDisplayed_
                   );


          positionTextInputPointer(vp);  // may have been changed by paint cell!
 

          // no nothing yet

       }

       // find the row and column on the screen and redraw the field there.
    }
}

static int textAtt(bool bold, bool underlined, bool reversed)
{
   int rv = CursorWindow::normal;

   if(bold && underlined && reversed)
   {
      return CursorWindow::dialog_title_att;
   }
   else
   if(bold && underlined)
   {
       return CursorWindow::inactive_title_att;
   }
   else
   if(bold && reversed)
   {
       return CursorWindow::active_title_att;
   }
   else
   if(underlined && reversed)
   {
       return CursorWindow::active_mark_att;
   }
   else
   if(underlined)
   {
      return CursorWindow::bottom_att;
   }
   else
   if(reversed)
   {
       return CursorWindow::highlighted_att;
   }
   else
   if(bold)
   {
       return CursorWindow::inactive_mark_att;
   }

   return rv;

}


void TableViewer::paintCell(CursorWindow::viewport *vp,
                            size_t vpRow, 
                            size_t vpCol, 
                            size_t tbRow, 
                            size_t tbCol, 
                            bool highlight,
                            bool editCursor 
                           )
{
    size_t vpColumns = colWidths_[tbCol];

    CellInfo const *cell = cellInfo(tbRow,tbCol);

    if(cell == 0)
       return;

    // position the cursor to the top left corner of the cell.
    // For each row, display the gutter, then display the row text
    // then pad with trailing blanks.
    //
    // right now just do one row


    vp->set_curpos(vpRow, vpCol);

    bool bold = rows_[tbRow].bold_  || cols_[tbCol].bold_;

    bool underline = rows_[tbRow].bottomBorder_;


    if(highlight && cursorDisplayed_)
    {
       vp->set_text_attribute(textAtt(bold, underline, true));
    }
    else
      vp->set_text_attribute(textAtt(bold, underline, false));

    if(cols_[tbCol].leftBorder_)
        *vp << "|"; // paint the gutter
    else
        *vp << " "; // paint the gutter


    paintField(vp, vpRow, vpCol, cell, 0, vpColumns, editCursor);


}
void TableViewer::paintField(CursorWindow::viewport      *vp,
                             size_t                       vpRow, 
                             size_t                       vpCol, 
                             TableViewer::CellInfo const *cell, 
                             size_t                       cellRow, 
                             size_t                       vpColumns,
                             bool                         ignored    // the base class doesn't support edit cursor
                            )
{
    // get the length of the data to display

    char const *data = "";
    size_t      length= 0;

    if(cell)
    {
      if(cell->text_.size() > cellRow)
      {
        data = cell->text_[cellRow].data();
        length = cell->text_[cellRow].size();
      }
    }

    if(length > vpColumns)
    {
       length = vpColumns;
    }

    vp->write(data, length);

    if(length < vpColumns)
        vp->write(' ', vpColumns - length);
}
void TableViewer::moveUp(CursorWindow::viewport *vp)
{
    if(cursorRow_ > originRow_)
    {
      setCursorInfo(vp, cursorRow_-1, cursorCol_, true);
      return;
    }

    // cursor was at top of screen, so if there are rows above this, display one more
    // than we currently see


    if(originRow())
    {
       size_t col = cursorCol_;

       hideCursor(vp);

       setOrigin( originRow() - 1, originCol() );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, originRow(), col);
    }
}
void TableViewer::moveDown(CursorWindow::viewport *vp)
{

    size_t pageDeltaRow = cursorRow_ - originRow();

    if(pageDeltaRow < pageHeight_-1)
    {
       setCursorInfo(vp, cursorRow_+1, cursorCol_, true);
       return;
    }
    
    if(rows() && cursorRow_ < rows()  )
    {
        size_t col = cursorCol_;

        hideCursor(vp);

        if(originRow() < rows()-1)
            setOrigin( originRow() + 1, originCol() );
        else
            setOrigin( rows()-1, originCol() );

        (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

        // pageHeight_ will have been recomputed. as will origin row and column

        setCursorInfo(vp, originRow() + pageHeight_-1, col ); 
    }



}
void TableViewer::moveLeft(CursorWindow::viewport *vp)
{
    if(cursorCol_ > originCol())
    {
       setCursorInfo(vp, cursorRow_, cursorCol_ - 1);
       return;
    }

    if(originCol())
    {
       size_t row = cursorRow_;

       hideCursor(vp);

       setOrigin( originRow(), originCol() - 1 );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, row, originCol());

    }
}
void TableViewer::moveRight(CursorWindow::viewport *vp)
{
    if(cursorCol_ < originCol() + pageWidth_ -1)
    {
        setCursorInfo(vp, cursorRow_, cursorCol_ +1);
        return;
    }

    // we must have been sitting on the right side of the screen

    if(originCol() < cols_.size()-1)
    {
       size_t row = cursorRow_;

       hideCursor(vp);

       setOrigin( originRow(), originCol() + 1 );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, row, originCol() + pageWidth_ -1);
    }
}

void TableViewer::pageUp(CursorWindow::viewport *vp)
{
    size_t pageHeight = vp->size().row_-1;

    {
       size_t savedCol = cursorCol_;

       if(originRow() < pageHeight)
       {
          setOrigin( 0, originCol() );
       }
       else
           setOrigin( originRow() - pageHeight, originCol() );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, originRow(), savedCol);
    }
}
void TableViewer::pageDown(CursorWindow::viewport *vp)
{
    size_t pageHeight = vp->size().row_-1;

    if(rows() && originRow() < layout_.size())
    {
       size_t targetRow = originRow() + pageHeight;

       if(  originRow() >= layout_.size()-1-pageHeight )
       {
           targetRow = layout_.size()-1;
       }

       size_t savedCol = cursorCol_;

       if(targetRow >= layout_.size())
         {
           if(layout_.size() == 0)
             targetRow = 0;
           else
             targetRow = layout_.size()-1;
         }

       setOrigin( targetRow, originCol() );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, originRow(), savedCol);
    }

}
void TableViewer::pageRight(CursorWindow::viewport *vp)
{
    if(cols_.size())
    {
        size_t newOrigin = originCol() + pageWidth_-1;

        if(newOrigin >= cols_.size())
        {
           // size is known not to be zero

           newOrigin = cols_.size()-1;

        }

        size_t colDelta = cursorCol_ - originCol_;

        if(newOrigin + colDelta >= cols_.size())
        {
           colDelta = 0;
        }

        size_t row = cursorRow_;
        
        hideCursor(vp);
        
        setOrigin( originRow(), newOrigin );
        
        (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
        
        setCursorInfo(vp, row, originCol() + colDelta);
    }
}

void TableViewer::pageLeft(CursorWindow::viewport *vp)
{
    size_t colDelta = cursorCol_ - originCol();
    size_t row      = cursorRow_;

    if(originCol() > pageWidth_-1)
    {
       size_t pageDelta = pageWidth_-1;

       if(pageDelta == 0 && originCol() > pageDelta)
           pageDelta = 1;

       hideCursor(vp);

       setOrigin( originRow(), originCol() - pageDelta );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, row, originCol() + colDelta);

    }
    else
    {
       hideCursor(vp);
       setOrigin(originRow(), 0);
       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
       setCursorInfo(vp, row, 0);
    }
}

void TableViewer::pageHome(CursorWindow::viewport *vp)
{
    setOrigin( 0, 0);

    (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
}

void TableViewer::pageEnd(CursorWindow::viewport *vp)
{
    if(cols_.size())
    {
       setOrigin( originRow(), cols_.size() - 1 );

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
    }
}
void TableViewer::pageBottom(CursorWindow::viewport *vp)
{
    if(rows())
    {
       size_t savedCursorCol = cursorCol_;
       size_t targetRow      = rows()-1;

       setOrigin( targetRow, originCol());

       (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

       setCursorInfo(vp, targetRow, savedCursorCol);

    }
}
void TableViewer::pageTop(CursorWindow::viewport *vp)
{
    size_t savedCursorCol = cursorCol_;

    setOrigin(0, originCol());

    (*this)(vp, CursorWindow::viewport::repaint_handler::activate);

    setCursorInfo(vp, 0, savedCursorCol);

}
void TableViewer::clear()
{
   rows_.clear();
   cols_.clear();
   layout_.clear();
   colWidths_.clear();

   setCursorInfo(0,0,0);
   setOrigin(0,0);

}
void TableViewer::positionTextInputPointer(CursorWindow::viewport *vp)
{
    vp->refresh();
    vp->set_curpos(textInputPointer_.row_, textInputPointer_.col_); // 1 for the gutter
}

void TableViewer::insertRowAbove(CursorWindow::viewport *vp, RowInfo const &info)
{
   LayoutType::iterator rowPointer = layout_.begin() + cursorRow_;

   layout_.insert(rowPointer, LayoutType::value_type());
   
   for(size_t col=0; col < cols_.size(); ++col)
   {
       layout_[cursorRow_].push_back(CellInfo()); // create empty cells

       layout_[cursorRow_].back().text_.push_back(""); // 1 empty row of text.
   }

   vector<RowInfo>::iterator rowIterator = rows_.begin()+cursorRow_;

   rows_.insert(rowIterator, info);

   forceRelayout();

}
void TableViewer::insertRowBelow(CursorWindow::viewport *vp, RowInfo const &info)
{
   if(cursorRow_ < layout_.size()-1)
   {
      // unless we are at the bottom, step down to the next row and insert
      // the new line above the line below

      ++cursorRow_;

      insertRowAbove(vp,info);
   }
   else
   {
       layout_.push_back(LayoutType::value_type());

       for(size_t col=0; col < cols_.size(); ++col)
       {
           layout_[cursorRow_].push_back(CellInfo()); // create empty cells
    
           layout_[cursorRow_].back().text_.push_back(""); // 1 empty row of text.
       }

       vector<RowInfo>::iterator rowIterator = rows_.begin()+cursorRow_;

       rows_.insert(rowIterator, info);

       ++cursorRow_;

    
       forceRelayout();
    


   }
}
void TableViewer::RowInfo::setRowTitleNumber(size_t row)
{
    char buffer[40];

    sprintf(buffer, "%lu", (unsigned long)row);

    title_ = buffer;
}

void TableViewer::deleteRow(CursorWindow::viewport *vp)
{
   // delete the current cursor row

   if(cursorRow_ < layout_.size())
   {
      LayoutType::iterator rowIterator = layout_.begin() + cursorRow_;

      layout_.erase(rowIterator);

      forceRelayout();
   }
}


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

  char const *mix = "Y";

  if(mixed_case_ == false)
    mix = "N";

  dialog += new CursorWindow::Dialog::String("case",
                                             "Mixed case",
                                             mix,
                                             2
                                            );


  dialog += new CursorWindow::Dialog::String("mode",
                                             "(W)ord, (R)egexp, or (S)tring",
                                             (is_regex_ ? "R" : (match_words_ ? "W" : "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 mixed_case = dialog.element_value("case");

  if(   mixed_case.size() 
     && (    mixed_case[0] == 'n'
         ||  mixed_case[0] == 'N'
        )
    )
  {
    mixed_case_ = false;
  }
  else
  if(    mixed_case.size() 
      && (mixed_case[0] == 'y' ||  mixed_case[0] == 'Y')
    )
  {
    mixed_case_ = true;
  }

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

  match_words_ = false;
  is_regex_    = false;

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

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

  if(search_text.size() == 0)
    return; // ignore searches for nothing

  search_text_ = search_text;

  findNext(vp, true);

}


struct CharCompare
{
  TableViewer const *impl_;

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

  CharCompare(TableViewer const* t)
  : impl_(t)
  {
  }

};


bool TableViewer::findNext(CursorWindow::viewport *vp, bool first)
{
   size_t row = cursorRow_;
   size_t col = cursorCol_;


   if(!first)
       ++col;

   SimpleRegex   regex(search_text_,  (mixed_case_ ? "i" : "") );


   while(row < layout_.size())
   {
       while(col < layout_[row].size())
       {
           if(layout_[row][col].text_.empty())
           {
              ++col;
              continue;
           }
           
           string const &cell = layout_[row][col].text_[0];
           
           bool found = false;

           if(is_regex_)
           {
               if( regex(cell, 0, cell.size() ) != 0)
                 found = true;
           }
           else
           {
               string::const_iterator match;

               string::const_iterator searchStart = cell.begin();
               string::const_iterator searchEnd   = cell.end();

               do
               {
                   match=search(searchStart, 
                                searchEnd, 
                                search_text_.begin(), 
                                search_text_.end(),
                                CharCompare(this)
                               );

                   if(match_words_)
                   {
                       if(match != searchEnd)
                       {
                         found = true;
                       
                         // we have found a match -- but if we are searching for
                         // words, it does not count as a match unless it is surrounded
                         // by word characters (or the bounds of the search space
                       
                         if(match != cell.begin())
                         {
                            string::const_iterator before = match; --before;
                       
                            if(isalnum(*before))
                            {
                              found = false;
                              ++searchStart;
                            }
                         }
                       
                         if(found)
                         {
                             string::const_iterator end = match+search_text_.size();
                       
                             if(end != searchEnd)
                             {
                                 if(isalnum(*end))
                                 {
                                   found = false;
                                   ++searchStart;
                                 }
                             }
                       
                         }
                       }
                   }
                   else
                   if(match != searchEnd)
                     found=true;
               }
               while(!found && match != searchEnd);
               

           }

           if(found)
           {
           
               hideCursor(vp);

               if(    row >= originRow() + pageHeight_
                  ||  col >= originCol() + pageWidth_
                  ||  col <  originCol()
                 )
               {
                   size_t rowBackoff = pageHeight_ / 2;
                   size_t colBackoff = pageWidth_  / 2;

                   size_t targetRow = row;
                   size_t targetCol = col;


                   if(targetRow > rowBackoff)
                      targetRow = row - rowBackoff;
                   else
                      targetRow = 0;
                  
                   if(targetCol > colBackoff)
                      targetCol = col - colBackoff;
                   else
                      targetCol = 0;


                   setOrigin(targetRow, targetCol);

                   (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
               }
           
               setCursorInfo(vp, row, col);
           
              return true;
           }

           ++col;
       }

       ++row;
       col=0;
   }

   vp->beep();

   return false;

}
} // namespace cxxtls