spreadtable.cpp

Go to the documentation of this file.

#include <qpainter.h>
#include <qimage.h>
#include <qlineedit.h>
#include <qpalette.h>
#include <typeinfo>
#include "iis.h"
#include "value.h"
#include "vars.h"
#include "refs.h"
#include "runtime.h"
#include "spreadsheet.h"
#include "version.h"

SpreadSheetTable::SpreadSheetTable( int numRows, int numCols, QWidget * parent, const char * name ):
  QTable(numRows, numCols, parent, name)
{
}

QWidget * SpreadSheetTable::beginEdit ( int row, int col, bool replace )
{
  if (!item(row,col))
    setItem(row,col,new IisCell(this, QTableItem::OnTyping ));
  return QTable::beginEdit(row,col,replace);
}

void SpreadSheetTable::queue_recalculation(IisCell * ss)
{
  if (!ss) return;
  restart_recalcing();
  if (needs_recalculation.empty())
    {
      needs_recalculation.push_back(ss);
      return;
    }
  for(list<IisCell*>::iterator it=needs_recalculation.begin() ;
      it != needs_recalculation.end() ;
      it++)
    if (*it==ss) return;
  needs_recalculation.push_back(ss);
}

void SpreadSheetTable::insertRows(int from, int nr)
{
  // the standard function allocates new row numbers, which is wrong,
  // we need to go through the entire table and shift all rows down
  // therefore we need to go from bottom to top through all the rows
  // we normally should not be changing the values, the formules however 
  // require updating
  // we cannot do this during recalculations,
  int br = numRows();
  int mc = numCols();
  for(int row = br-1-nr ; row >=0; row--)
    for(int col = 0 ; col <mc ; col++)
      {
        QTableItem * i = item(row,col);
        if (row>=from)
          {
            takeItem(i);
            setItem(row+nr,col,i);
            setItem(row,col,NULL);
          }
        if (i)
          {
            IisCell * ss = (IisCell*)i;
            ss->rowsInserted(from,nr);
          }
      }
}

void SpreadSheetTable::insertCols(int from, int nr)
{
  int br = numRows();
  int mc = numCols();
  for(int col = mc-1-nr ; col >=0 ; col--)
    for(int row = 0 ; row <br; row++)
      {
        QTableItem * i = item(row,col);
        if (col>=from)
          {
            takeItem(i);
            setItem(row,col+nr,i);
            setItem(row,col,NULL);
          }
        if (i)
          {
            IisCell * ss = (IisCell*)i;
            ss->colsInserted(from,nr);
          }
      }
}

void SpreadSheetTable::insertRows()
{
  // find the selection
  int cs = currentSelection();
  if (cs>=0)
    {
      QTableSelection S = selection(cs);
      int tr = S.topRow();
      int br = S.bottomRow();
      printf("Inserting %d rows at %d\n",1+br-tr,tr);
      insertRows(tr,1+br-tr);
    }
  else
    {
      printf("Inserting 1 row at %d\n",currentRow());
      insertRows(currentRow(),1);
    }
}

void SpreadSheetTable::insertCols()
{
  // find the selection
  int cs = currentSelection();
  if (cs>=0)
    {
      QTableSelection S = selection(cs);
      int br = S.rightCol();
      int tr = S.leftCol();
      printf("Inserting %d cols at %d\n",1+br-tr,tr);
      insertCols(tr,1+br-tr);
    }
  else
    {
      printf("Inserting 1 col at %d\n",currentColumn());
      insertCols(currentColumn(),1);
    }
}

void SpreadSheetTable::copyRight()
{
  int cs = currentSelection();
  if (cs==-1) return;
  QTableSelection S = selection(cs);
  for(int row = S.topRow() ; row <= S.bottomRow() ; row++)
    {
      IisCell *left = (IisCell*)item(row,S.leftCol());
      if (left)
        {
          for(int col = S.leftCol() + 1; col <= S.rightCol() ; col++)
            {
              if (!item(row,col))
                setItem(row,col,new IisCell(this, QTableItem::OnTyping ));
              setText(row,col,left->getFormuleTextForCell(col,row));
            }
        }
    }
}

void SpreadSheetTable::copyDown()
{
  int cs = currentSelection();
  if (cs==-1) return;
  QTableSelection S = selection(cs);
  for(int col = S.leftCol() ; col <= S.rightCol() ; col++)
    {
      IisCell *top = (IisCell*)item(S.topRow(),col);
      if (top)
        for(int row = S.topRow() + 1 ; row <= S.bottomRow() ; row++)
          {
            if (!item(row,col))
              setItem(row,col,new IisCell(this, QTableItem::OnTyping ));
            setText(row,col,top->getFormuleTextForCell(col,row));
          }
    }
}

void SpreadSheetTable::restart_recalcing()
{
  mainapp->postEvent(this,new QCustomEvent(QEvent::User+1));
}

void SpreadSheetTable::recalc()
{
  if (needs_recalculation.empty())
    return;
  IisCell * found = NULL;
  list<IisCell*>::iterator it;
  for(it = needs_recalculation.begin() ; it != needs_recalculation.end(); it++)
    {
      IisCell *sc = *it;
      assert(sc);
      if (sc->can_be_calculated_now())
        {
          found=sc;
          break;
        }
    }
  if (!found) return;
  needs_recalculation.erase(it);
  found->recalc();
  if (!needs_recalculation.empty())
    restart_recalcing();
}

void SpreadSheetTable::customEvent( QCustomEvent * e )
{
  if ( e->type() == QEvent::User+1 )
    recalc();
}

void SpreadSheetTable::status_selection(bool force_recalc, bool allow_ui)
{
  if (numSelections()==0)
    {
      IisCell * s = (IisCell *)item(currentRow(),currentColumn());
      if (!s) return;
      if (force_recalc) s->mark_recalc();
      if (allow_ui) s->mark_allow_ui();
    }
  else
    for(int i = 0 ; i < numSelections() ; i ++)
      {
        QTableSelection ts = selection(i);
        if (!ts.isActive()) continue;
        if (ts.isEmpty()) continue;
        for(int x = ts.leftCol() ; x <= ts.rightCol() ; x++)
          for(int y = ts.topRow() ; y <= ts.bottomRow() ; y++)
            {
              IisCell * s = (IisCell *)item(y,x);
              if (!s) continue;
              if (force_recalc) s->mark_recalc();
              if (allow_ui) s->mark_allow_ui();
            }
      }
  restart_recalcing();
}

IisCell * SpreadSheetTable::findItem(int row, int col)
{
  IisCell * sc = (IisCell *) item(row,col);
  if (sc) return sc;
  // printf("Unable to find item at row %d and col %d\n",row,col);
  sc = new IisCell(this, QTableItem::OnTyping);
  setItem(row,col,sc);
  return sc;
}

void SpreadSheetTable::saveFile(QString filename_prefix)
{
  int br = numRows();
  int mc = numCols();
  // count the number;
  int count = 0;
  for(int col = 0 ; col < mc ; col++)
    for(int row = 0 ; row < br; row++)
      if (item(row,col)) count++;
  Array<2,Data> content(count,2);
  int pos = 0;
  for(int col = 0 ; col < mc ; col++)
    for(int row = 0 ; row < br; row++)
      {
        QTableItem * i = item(row,col);
        if (!i) continue;
        Reference ref(col,row,false,false);
        content[Position<2>(pos,0)]=ref.getSaveDescription(filename_prefix);
        IisCell * c = (IisCell*)i;
        content[Position<2>(pos,1)]=c->saveFile(filename_prefix);
        pos++;
      }
  Token all;
  all["data"]=content;
  all["version"]=String(IIS_VERSION);
  QString actual_filename = filename_prefix;
  if (!actual_filename.endsWith(IIS_EXTENSION))
    actual_filename+=IIS_EXTENSION;
  DataTexter::write(all,actual_filename);
}

void SpreadSheetTable::loadFile(QString filename)
{
  Data all_unlabeled = DataTexter::read_file((const char*)filename);
  Token all = all_unlabeled;
  Data general_content = all["data"];
  String version = (String)all["version"];
  Array<2,Data> content = general_content;
  // go through all the cells
  for(Array<2,Data>::vector_values i(content,0) ; i.more(); ++i)
    {
      Array<1,Data> &cell = i;
      Reference cellid((Token)cell[0]);
      IisCell * spreadcell = findItem(cellid.row,cellid.column);
      assert(spreadcell);
      Data   cellcontent = cell[1];
      spreadcell->load(cellcontent);
    }
}

---