tableeditor.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/tableeditor.h>
#include <cxxtls/viewermanager.h>
#include <iostream>
#include <fstream>
#include <cxxtls/strtool.h>
#include <cxxtls/file.h>

using namespace std;

namespace cxxtls
{

TableEditor::~TableEditor()
{
}
TableEditor::TableEditor(ViewerManager *vm, int delimiter)
: TableViewer(vm)
, fieldEditColumn_(0)
, delimiter_(delimiter)
, keyKludge_(0)
{
  set_data_dirty(false);
}
TableViewer::CellInfo *TableEditor::editCell()
{
   if(rows() && cols())
   {
       CursorInfo cursor = cursorInfo();

       return cellInfo(cursor.row_, cursor.col_);

   }

   return 0;
}
bool TableEditor::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: // ^C quit editing
                   return true;


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

            return false;
        }

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

        if(isTableEditKey(e) && !fieldEditable(cursorInfo()))
        {
           vp->beep();
           return false;
        }


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

           case 0x10: // ^P
           {
               pageRight(vp);
           }
           return false;

           case 0x11: // ^Q
           {
               pageLeft(vp);
           }
           return false;

           case 0x09: // TAB
           {
               moveRight(vp);
           }
           return false;

           case CursorWindow::key_btab: // shift tab
           {
               moveLeft(vp);
           }
           return false;



           case 0x01: // ^A -- got to beginning of cell line
           {
               CellInfo  *cell = editCell();
           
               if(cell)
               {
                  if(cell->text_.size())
                  {
                     // assume we only edit row 0 for the moment
           
                     fieldEditColumn_ = 0;
                     paintCursor(vp);
                  }
               }
           
           }
           return false;

           case 0x05: // control e -- go to end of cell
           {
               CellInfo  *cell = editCell();
           
               if(cell)
               {
                  if(cell->text_.size())
                  {
                     // assume we only edit row 0 for the moment
           
                     fieldEditColumn_ = cell->text_[0].size();
                     paintCursor(vp);
                  }
               }
           
           }
           return false;


           case CursorWindow::key_dc:  
           {

               CellInfo  *cell = editCell();
           
               if(cell)
               {
                  if(cell->text_.size())
                  {
                     // assume we only edit row 0 for the moment
           
                     string &text = cell->text_[0];
           
                     if(fieldEditColumn_ < text.size())
                     {
                        set_data_dirty(true);

                        text.erase(fieldEditColumn_, 1);
                        
                        checkLayoutRecompute();

                        paintCursor(vp);
                     }
           
                  }
               }
           
           }
           return false;

           case CursorWindow::key_bs:  
           {
               
               CellInfo  *cell = editCell();
           
               if(cell)
               {
                  if(cell->text_.size())
                  {
                     // assume we only edit row 0 for the moment
           
                     string &text = cell->text_[0];
           
                     if(fieldEditColumn_ <= text.size() && fieldEditColumn_ > 0)
                     {
                        set_data_dirty(true);

                        --fieldEditColumn_;

                        text.erase(fieldEditColumn_, 1);
           
                        checkLayoutRecompute();

                        paintCursor(vp);
                     }
           
                  }
               }
           
           }
           return false;

           case CursorWindow::key_left:  
           {
               // Key left works like this:
               // If you are sitting in the left most column of an
               // cell, it will jump you to the previous cell.
               // On the other hand, if you are in the middle or at
               // the end of a cell, it will merely move the cursor
               // back one column.

               CellInfo  *cell = editCell();
           
               if(cell)
               {
                     // assume we only edit row 0 for the moment
           
                     if(fieldEditColumn_)
                     {
                         --fieldEditColumn_;
                         paintCursor(vp);
                         return false;
                     }
               }
           
           }
           break; // not return false!

           case CursorWindow::key_right:  
           {
               // Key right works like this:
               // If you are sitting at the end of the text in a cell
               // cell, it will jump you to the next cell.
               // On the other hand, if you are in the middle or at
               // the beginning of a cell, it will merely move the cursor
               // to the right one column.

               CellInfo  *cell = editCell();
           
               if(cell)
               {
                  
                  if(cell->text_.size())
                  {
                     // assume we only edit row 0 for the moment
           
                     string &text = cell->text_[0];
           
                     if(fieldEditColumn_ < text.size())
                     {
                        ++fieldEditColumn_;
           
                        paintCursor(vp);

                        return false;
                     }
           
                  }
               }
           
           }
           break; // not return false!


           case CursorWindow::key_f9: // insert row above
           {
               RowInfo ri;

               TableViewer::CursorInfo info = cursorInfo();

               ri.setRowTitleNumber(info.row_+1);


               TableViewer::insertRowAbove(vp, ri);

               for(size_t i = 0; i < rows(); ++i)
               {
                   ri = rowInfo(i);

                   ri.setRowTitleNumber(i+1);

                   setRowInfo(i, ri);

               }


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

               TableViewer::setCursorInfo(vp, info);


           }
           return false;


           case 0x0d: // carriage return ^M
           case 0x0a: // (line feed ^J) insert row below
           {

               RowInfo ri;

               TableViewer::CursorInfo info = cursorInfo();

               ri.setRowTitleNumber(info.row_+2);


               TableViewer::insertRowBelow(vp, ri);

               for(size_t i = 0; i < rows(); ++i)
               {
                   ri = rowInfo(i);

                   ri.setRowTitleNumber(i+1);
                   

                   setRowInfo(i, ri);

               }

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

               TableViewer::setCursorInfo(vp, info);
           }
           return false;

           case CursorWindow::key_f8: // delete row
           {
               TableViewer::CursorInfo info = cursorInfo();

               if(info.row_ < rows_.size())
               {

                   RowInfo ri;
                   
                   
                   TableViewer::deleteRow(vp);
                   
                   for(size_t i = 0; i < rows(); ++i)
                   {
                       ri = rowInfo(i);
                   
                       ri.setRowTitleNumber(i+1);
                   
                       setRowInfo(i, ri);
                   
                   }
                   
                   (*this)(vp, CursorWindow::viewport::repaint_handler::activate);
                   
                   TableViewer::setCursorInfo(vp, info);
               }
           }
           return false;


           default:

               if(e->type_ == CursorWindow::input_event::DataKey)
               {
                   set_data_dirty(true);

                   if(e->value_ >= ' ' && e->value_ < 0x7f)
                   {
                      char data = e->value_;

                      if(data == delimiter_)
                      {
                        vp->beep();
                        data = ' ';
                      }

                      CellInfo *cell = editCell();

                      if(cell)
                      {
                        
                         if(cell->text_.empty())
                         {
                           cell->text_.push_back("");
                         }

                         {
                            // assume we only edit row 0 for the moment
                      
                            string &text = cell->text_[0];
                      
                            if(fieldEditColumn_ > text.size())
                            {
                               fieldEditColumn_ = text.size();
                            }

                            text.insert(fieldEditColumn_, 1, data);

                            ++fieldEditColumn_;

                            checkLayoutRecompute();

                            paintCursor(vp);

                            return false; 
                         }
                      }
                   }
               }

               break;

        }
    }

   // by default, act like a table viewer -- which has different arrow key behavior
   // than is inforced here

   bool quitNow = TableViewer::handle_event(e,vp);

   return quitNow;
}

void TableEditor::snatchEdit(CursorWindow::viewport *vp, FileName const &directory)
{
  
    // note:  directory MUST include the trailing /


    CellInfo *cell = editCell();
    
    if(cell)
    {
      
        string &text = cell->text_[0];
        
        if(fieldEditColumn_ < text.size())
        {
            string operand(  text.begin() + fieldEditColumn_, text.end() );

            FileName filename;
            int    lineNo = 0;

            string tmp;

            bool success = StrTool::snatch_file_info(operand, tmp, lineNo);

            if(success)
            {
                filename = manager_->find_file_in_standard_locations(tmp, directory);

                if(!filename.empty())
                {

                    Viewer* oldie = manager_->find_viewer(filename);
                    
                    if(oldie)
                    {
                      if(lineNo > 0)
                          oldie->set_row_col_hint(lineNo-1,0);

                      manager_->activate(oldie);
                    }
                    else
                    {
                      if(!filename.exists())
                      {
                         CursorWindow::Message m(filename + " does not exist");
                    
                         m += "Sorry, can't find it";
                         m += "";
                         m += "Press Enter to continue";
                    
                         m.popup(manager_->window());
                    
                         return;
                      }
                    
                      Viewer *newbie = manager_->edit(filename);
                    
                      if(!newbie)
                        manager_->window()->beep();
                      else
                      {
                        if(lineNo > 0)
                            newbie->set_row_col_hint(lineNo-1, 0);  // 0 based line numbers!

                        manager_->vsplit(newbie, filename);
                      }
                    
                    }

                   
                }
                else
                {
                   CursorWindow::Message m(string("Error:  ") + tmp);
                  
                   m += "File cannot be found";
                   m += "";
                   m += "Press Enter to continue";
                  
                   m.popup(manager_->window());
                }

            }
            else
            {
               CursorWindow::Message m("Error");
              
               m += "The cell you are in does not contain a file name";
               m += "at the current cursor position.";
               m += "";
               m += "Press Enter to continue";
              
               m.popup(manager_->window());
            }
        }
    }


    // we get here only some kind of error

    vp->beep();
}



void TableEditor::setCursorInfo(CursorWindow::viewport *vp,
                              size_t worldRow, 
                              size_t worldCol, 
                              bool displayed
                             )
{
    terminateInput();

    TableViewer::setCursorInfo(vp, worldRow, worldCol, displayed);
}

void TableEditor::terminateInput()
{
   fieldEditColumn_ = 0;
}

void TableEditor::paintField(CursorWindow::viewport *vp,
                           size_t                       vpRow,
                           size_t                       vpCol,
                           TableViewer::CellInfo const *cell,
                           size_t                       cellRow,
                           size_t                       vpColumns,
                           bool                         editCursor
                          )
{
   // the cursor is already positioned to vpRow, vpCol+1 when we get here!

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

   size_t vpRemainingColumns = vpSize.col_ - vpCol;  

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


   if(cell == 0 )
      return;

   if(    cell->text_.size() <= cellRow
      ||  cell->text_[cellRow].size() < vpColumns
     )
   {
       TableViewer::paintField(vp, vpRow, vpCol, cell, cellRow, vpColumns, editCursor);

       setTextInputPointer(vpRow, vpCol + 1 + fieldEditColumn_);
   }
   else
   {
       // the text is too big to fit in the cell.
    
       string const &text = cell->text_[cellRow];
    
       if(fieldEditColumn_ == text.size())
       {
          // paint the tail of the string and put the cursor 1 character past the
          // end of the string.
    
          char const *p = text.data() + text.size() - vpColumns + 2;
    
          vp->write(p, vpColumns-2);

          *vp << "  ";

          setTextInputPointer(vpRow, vpCol + vpColumns-1);
    
       }
       else
       {
          // the cursor is in the middle of the string 

          char const *p = text.data(); 

          size_t charOffset = 0;

          if(fieldEditColumn_ > text.size())
          {
            fieldEditColumn_ = text.size();
          }

          if(fieldEditColumn_+1 >= vpColumns)
          {
            charOffset = (fieldEditColumn_+2) - vpColumns;
          }

          size_t remainingLength = text.size() - charOffset;

          if(remainingLength > vpColumns)
             remainingLength = vpColumns;

          vp->write(p + charOffset, remainingLength);

          CursorWindow::row_col curpos;

          if(remainingLength < vpColumns)
          {
             
             curpos = vp->curpos();

             vp->write(' ', vpColumns - remainingLength);

             curpos = vp->curpos();

          }

          CursorWindow::row_col cp= vp->curpos();


          setTextInputPointer(vpRow, vpCol + 1 + fieldEditColumn_ - charOffset);

          if(editCursor)
          {
              if(size_t(cp.row_) != vpRow || cp.col_ >= vpSize.col_)
              {
                // page too wide for screen, wrap around occurred on write
    
                vp->set_curpos(vpRow, vpCol + vpColumns-1);
    
              }
              else
              {
                vp->set_curpos(vpRow, vpCol + 1 + fieldEditColumn_ - charOffset);
              }
          }

       }
   }

}

bool TableEditor::isTableEditKey(CursorWindow::input_event const * e)
{
  if(e->value_ >= ' ' && e->value_ <= '~')
    return true;

  switch(e->value_)
  {
     case                 0x08:  return true;
     case CursorWindow::key_dc:  return true;
     case CursorWindow::key_bs:  return true;

  }


   return false;
}

} // namespace cxxtls