iiscell.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 "ranges.h"
#include "runtime.h"
#include "spreadsheet.h"
#include "text.h"
#include "parser.h"
#include "status.h"

//---------------------------------------------------------------
//                           Net stuff
//---------------------------------------------------------------
bool equals(QString a, QString b)
{
  return a==b;
}

bool equals(bool a, bool b)
{
  return a==b;
}

bool equals(QImage a, QImage b)
{
  if (a.isNull() && b.isNull()) return true;
  if (a.isNull() || b.isNull()) return false;
  return a==b;
}

bool equals(Value * v1, Value * v2)
{
  if (v1==v2) return true;
  if (v1==NULL || v2==NULL)
    return false;
  if (v1->equals(v2))
    return true;
  return false;
}

class CallMember: public PlaceListener
{
public:
  IisCell::member F;
  IisCell& o;
  CallMember(IisCell &ob, IisCell::member i) : o(ob) 
    {
    F=i;
  };
  virtual void setChanged()
  {
    if (!changed)
      {
        o.queueCall(this);
      }
    PlaceListener::setChanged();
  }
  void execute()
  {
    ((o).*(F))();
  };
};

void IisCell::link(AbstractPlace& l, IisCell::member m)
{
  CallMember * em;
  em = new CallMember(*this,m);
  l.notify(em);
};

static vector<CallMember*> queued_calls;

void IisCell::queueCall(CallMember * m)
{
  queued_calls.push_back(m);
}

void IisCell::flushCalls()
{
  static bool flushing = false;
  if (flushing) return;
  flushing = true;
  while(queued_calls.size())
    {
      CallMember * m = queued_calls.front();
      queued_calls.erase(queued_calls.begin());
      m->clearChanged();
      m->execute();
    };
  flushing = false;
}

//---------------------------------------------------------------
//              The actual IisCell
//---------------------------------------------------------------
IisCell::IisCell(QTable * table, EditType et) :
  QTableItem(table,et)
{
  link(entered,     &IisCell::entered_changed);
  link(value,       &IisCell::value_changed);
  link(formule,     &IisCell::formule_changed);
  link(image,       &IisCell::image_changed);
  link(show,        &IisCell::show_changed);
  link(needs_recalculation,&IisCell::recalc_changed);

  link(entered,     &IisCell::show_status_changed);
  link(show_status, &IisCell::show_status_changed);

  link(image,       &IisCell::visual_changed);
  link(show,        &IisCell::visual_changed);
  link(needs_recalculation,&IisCell::visual_changed);
  
  entered = "";
  formule = NULL;
  value = NULL;
  needs_recalculation = false;
  user_input_allowed  = false;
  image = QImage();
  scaled = QImage();
  scale_xs = 0;
  scale_ys = 0;
  setWordWrap(true);
  show_status = true;
  
  flushCalls();
};

void IisCell::load(Data initfrom) 
{
  Token content = initfrom;
  String E = content["entered"];
  entered = E;
  Data F = content["formule"];
  if (!F.isNull())
    formule = Value::load(F);
  Data R = content["result"];
  if (!R.isNull())
    value = Value::load(R);
  // connect to the right cells
  set_inputs();

  flushCalls();
};

Data IisCell::saveFile(QString prefix)
{
  Token content;
  content["entered"]=String(entered);
  Value * F = formule;
  if (F)
    content["formule"]=F->getSaveDescription(prefix);
  Value * result = value;
  if (result)
    content["result"]=result->getSaveDescription(prefix);
  return content;
}

QWidget * IisCell::createEditor () const
{
  QWidget * res = QTableItem::createEditor();
  QLineEdit * le = (QLineEdit*)(void*)res;
  le->setText(entered);
  return le;
};

void IisCell::add_listener(IisCell * who)
{
  for(list<IisCell*>::iterator it=listeners.begin() ; it!=listeners.end() ; it++)
    {
      IisCell * c = *it;
      if (c==who) return;
    }
  listeners.push_back(who);
}

void IisCell::image_changed()
{
  QImage I = image;
  scaled = QImage();
  if (!I.isNull())
    show = NULL;
}

void IisCell::show_changed()
{
  QString S = show;
  QTableItem::setText(S);
  if (!S.isEmpty())
    image = QImage();
}

void IisCell::visual_changed()
{
  table()->updateCell(row(),col());
}

void IisCell::del_listener(IisCell * who)
{
  for(list<IisCell*>::iterator it=listeners.begin() ; it!=listeners.end() ; it++)
    if ((*it)==who) 
      {
        listeners.erase(it);
        return;
      }
}

class CellShifter: public ReferenceFixer
{
protected: int from, nr;
public:    CellShifter(int r, int c) : from(r), nr(c) {};
};


class CellDownShifter: public CellShifter
{
public:    
  CellDownShifter(int f, int c) : CellShifter(f,c) 
  {
  };
protected: 
  Reference* copyRef(Reference * ref)
  {
    assert(ref);
    if (ref->row>=from) ref->row+=nr;
    return ref;
  }
};

class CellRightShifter: public CellShifter
{
public:   
  CellRightShifter(int f, int c) : CellShifter(f,c) 
  {
  };
protected: 
  Reference* copyRef(Reference * ref)
  {
    if (ref->column>=from) ref->column+=nr;
    return ref;
  }
};

void IisCell::rowsInserted(int row, int nr)
{
  if (formule)
    {
      CellDownShifter shifter(row,nr);
      shifter.copy(formule);
    }
}

void IisCell::colsInserted(int col, int nr)
{
  if (formule)
    {
      CellRightShifter shifter(col,nr);
      shifter.copy(formule);
    }
}

class RelativeShifter: public ReferenceFixer
{
  int x,y;
  public:    RelativeShifter(int X, int Y) : x(X), y(Y) {};
  protected: Reference* copyRef(Reference *ref)
  {
    Reference *result=new Reference(*ref);
    if (!ref->absolute_col) 
      result->column+=x;
    if (!ref->absolute_row)
      result->row+=y;
    return result;
  }
};


QString IisCell::getFormuleTextForCell(int x, int y)
{
  if (!formule) return "";
  RelativeShifter shifter(x-col(),y-row());
  return shifter.copy(formule)->toString();
}

void IisCell::setText(const QString & str)
{
  entered = str;
  flushCalls();
}

void IisCell::entered_changed()
{
  QString e = entered;
  if (e.isEmpty())
    formule = NULL;
  else
    {
      try
        {
          ParseText p(e);
          formule = p.expr();
        }
      catch (Error * p)
        {
          formule = NULL;
          value = p;
        }
    }
}

void IisCell::formule_changed()
{
  clear_inputs();
  set_inputs();
  if (will_loop())
    {
      clear_inputs(); 
      value = new Error("<loop>");
      formule = NULL;
      return;
    }
  //  value = NULL;
  mark_recalc();
  
  // backward, when the formule updates, the entered formule
  // should be updated as well
  Value * F = formule;
  if (F) 
    entered = F->toString();
}

Value * IisCell::fetch_value()
{
  if (needs_recalculation) return NULL;
  Value * v = value;
  if (v &&
      (typeid(*v) == typeid(Status)
       || typeid(*v) == typeid(Error)
       || typeid(*v) == typeid(ParseError)))
    return NULL;
  return v;
}

void IisCell::updated()
{
  printf("  Updated cell %d,%d\n",col(),row());
  for(list<IisCell*>::iterator it=listeners.begin(); it!=listeners.end(); it++)
    {
      assert(*it);
      printf("    Marking recalc at %d,%d\n",(*it)->col(),(*it)->row());
      (*it)->mark_recalc();
    }
}

void IisCell::value_changed()
{
  if (!show_status)
    show_value();
  updated();
}

void IisCell::show_value()
{
  Value * result = value;
  if (!result)
    {
      show_status = true; 
    }
  else
    {
      if (typeid(*result)==typeid(ImageValue))
        image = ((ImageValue*)result)->getQImage(true);
      else 
        show = result->toString();
    }
}

void IisCell::show_status_changed()
{
  if (show_status)
    show = entered;
  else
    show_value();
}

void IisCell::paint(QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected)
{
  // determine color
  QColorGroup ncg(cg);
  Value * v = value;
  if (v && typeid(*v)==typeid(ParseError))
    ncg.setColor(QColorGroup::Base,QColor(255,0,0));
  else if (v && typeid(*v)==typeid(Error))
    ncg.setColor(QColorGroup::Base,QColor(255,192,192));
  else if (user_input_allowed)
    ncg.setColor(QColorGroup::Base,QColor(128,255,128));
  else if (needs_user_input())
    {
      if (needs_recalculation || show_status)
        ncg.setColor(QColorGroup::Base,QColor(255,192,128));
      else
        ncg.setColor(QColorGroup::Base,QColor(255,255,128));
    }
  else if (needs_recalculation || show_status)
    ncg.setColor(QColorGroup::Base,QColor(192,192,192));

  // paint text
  QImage I = image;
  if (I.isNull())
    {
      QTableItem::paint(p,ncg,cr,selected);
      return;
    }

  // if we have a pixmap we draw the content ourselves
  int height = table()->rowHeight(row());
  int width = table()->columnWidth(col());
  if (scaled.isNull() ||
      width!=scale_xs || 
      height!=scale_ys ||
      scaled.isNull())
    {
      scale_xs = width;
      scale_ys = height;
      scaled = I.smoothScale(scale_xs,scale_ys,QImage::ScaleMin);

      // draw the coordinate system
      if (value)
        {
          Value * v = value;
          if (typeid(*v)==typeid(ImageValue))
            {
              ImageValue* V = (ImageValue*)v;
              V->drawAxes(&scaled);
            }
        }
   }
  int xs = scaled.width();
  int ys = scaled.height();
  // top left corner
  int xl = (width - xs) / 2;
  int xr = xl + xs;
  int yt = (height - ys) / 2;
  int yb = yt + ys;
  QBrush b(ncg.color(QColorGroup::Base));
  p->fillRect(0,0,xl,height,b);
  p->fillRect(xr,0,width-xr+1,height,b);
  p->fillRect(xl,0,xs,yt,b);
  p->fillRect(xl,yb,xs,height-yb+1,b);
  p->drawImage(xl,yt,scaled);
};

void IisCell::recalc_changed()
{
  if (needs_recalculation)
    {
      value = NULL;
      show_status = true;
      SpreadSheetTable * ss = (SpreadSheetTable*)table();
      assert(ss);
      printf("      Queueing recalc at %d,%d\n",col(),row());
      ss->queue_recalculation(this);
      updated();
    }
}

void IisCell::mark_recalc()
{
  needs_recalculation = true;
  flushCalls();
}

void IisCell::mark_allow_ui()
{
  if (needs_user_input())
    user_input_allowed=true;
}

void IisCell::clear_inputs() 
{
  mark_inputs(false);
  inputs.clear();
}

void IisCell::set_inputs() 
{
  gather_inputs(formule);
  mark_inputs(true);
};

void IisCell::gather_inputs(Value * v)
{
  if (!v) return;
  if (typeid(*v)==typeid(TextValue)) return;
  if (typeid(*v)==typeid(ImageValue)) return;
  if (typeid(*v)==typeid(Reference))
    {
      // check position
      Reference *vv = (Reference*)v;
      assert(vv);
      SpreadSheetTable * ss = (SpreadSheetTable*)table();
      assert(ss);
      IisCell * sc = ss->findItem(vv->row,vv->column);
      assert(sc);
      inputs.push_back(sc);
      return;
    }
  if (typeid(*v)==typeid(Range))
    {
      // check position
      Range * r = (Range*)v;
      SpreadSheetTable * ss = (SpreadSheetTable*)table();
      assert(ss);
      for(int x = r->from->column ; x <= r->to->column ; x++)
        for(int y = r->from->row ; y <= r->to->row ; y++)
          {
            IisCell * sc = ss->findItem(y,x);
            assert(sc);
            inputs.push_back(sc);
          }
      return;
    }
  if (typeid(*v)==typeid(Expression))
    {
      Expression * e = (Expression*)v;
      for(int i = 0 ; i < e->argc() ; i++)
        gather_inputs(e->argv(i));
      return;
    }
  assert(0);
}


bool IisCell::needs_user_input()
{
  return runtime.requires_user_input(formule);
}

bool IisCell::can_be_calculated_now()
{
  // printf("Can cell %d,%d be recalculated ?\n",col(),row());
  for (list<IisCell*>::iterator it = inputs.begin();
       it!=inputs.end() ; it++)
    {
      bool nr = (*it)->needs_recalculation;
      // printf("  Input %d,%d: %d\n",(*it)->col(),(*it)->row(),nr);
      if ((*it)->needs_recalculation) 
        return false;
    }
  if (user_input_allowed) return true;
  return (!needs_user_input());
}

void IisCell::mark_inputs(bool add)
{
  for (list<IisCell*>::iterator it = inputs.begin() ; 
       it!=inputs.end() ; it++)
    {
      IisCell * sc = *it;
      if (add) 
        sc->add_listener(this);
      else
        sc->del_listener(this);
    }
}

bool IisCell::will_loop() 
{
  for (list<IisCell*>::iterator it = listeners.begin() ; 
       it!=listeners.end() ; it++)
    {
      IisCell * sc = *it;
      assert(sc);
      if (sc->will_influence(this)) return true;
    }
  return false;
};

bool IisCell::will_influence(IisCell * target)
{
  if (this == target) return true;
  for (list<IisCell*>::iterator it = listeners.begin() ; 
       it!=listeners.end() ; it++)
    {
      IisCell * sc = *it;
      assert(sc);
      if (sc->will_influence(target)) return true;
    }
  return false;
}

void IisCell::recalc()
{
  needs_recalculation = false;
  user_input_allowed = false;
  printf("Recalcing %d,%d\n",col(),row());
  if (formule != NULL)
    {
      try
        {
          value = evaluate(formule);
        }
      catch (Error * e)
        {
          value = e;
        }
    }
  else
    {
      value = NULL;
    }
  show_status = false;
  flushCalls();
}

Value * IisCell::lookup(Reference* var)
{
  if (!var) return NULL;
  SpreadSheetTable * ss = (SpreadSheetTable*)table();
  IisCell * i = (IisCell*)(ss->item(var->row,var->column));
  if (!i) return new TextValue("");
  return i->fetch_value();
}

Value * IisCell::lookup(Range* var)
{
  if (!var) return NULL;
  SpreadSheetTable * ss = (SpreadSheetTable*)table();
  int mx = var->from->column;
  int my = var->from->row;
  ValueArray * result = new ValueArray(var->to->column - var->from->column + 1,
                                       var->to->row    - var->from->row    + 1);
  for(int x = mx ; x <= var->to->column ; x++)
    for(int y = my ; y <= var->to->row ; y++)
      {
        Value * val;
        IisCell * i = (IisCell*)(ss->item(y,x));
        if (!i) val = new TextValue("");
        else val = i->fetch_value();
        if (!val) return NULL;
        result->set(x-mx,y-my,val);
      }
  return result;
}

Value *IisCell::evaluate(Value * what)
{
  if (!what) throw new Error("Empty formule");
  if (typeid(*what)==typeid(TextValue))
    return what;
  if (typeid(*what)==typeid(ImageValue))
    return what;
  //  if (typeid(*what)==typeid(VarValue))
  //    return lookup((VarValue*)what);
  if (typeid(*what)==typeid(Reference))
    return lookup((Reference*)what);
  if (typeid(*what)==typeid(Range))
    return lookup((Range*)what);
  if (typeid(*what)==typeid(Expression))
    return apply((Expression*)what);
  assert(0);
  return NULL;
}

Value *IisCell::apply(Expression * app)
{
  assert(app);
  // evaluate arguments
  vector<Value*> evaluated;
  for(int i = 0 ; i < app->argc() ; i++)
    evaluated.push_back(evaluate(app->argv(i)));
  // check operator
  return runtime.apply(app->op(),evaluated);
}

---