IisCell Class Reference

#include <iiscell.h>

List of all members.

Public Types
typedef void(IisCell::*	member )()
Public Member Functions
void	mark_recalc ()
bool	needs_user_input ()
void	mark_allow_ui ()
	IisCell (QTable *table, EditType et)
virtual void	setText (const QString &str)
void	recalc ()
bool	can_be_calculated_now ()
QString	getFormuleTextForCell (int x, int y)
QWidget *	createEditor () const
void	rowsInserted (int row, int nr)
void	colsInserted (int col, int nr)
virtual void	paint (QPainter *p, const QColorGroup &cg, const QRect &cr, bool selected)
Data	saveFile (QString prefix)
void	load (Data data)
Protected Member Functions
bool	will_influence (IisCell *)
bool	will_loop ()
Private Member Functions
void	link (AbstractPlace &, member)
void	queueCall (CallMember *m)
void	flushCalls ()
void	image_changed ()
void	show_changed ()
void	visual_changed ()
void	show_value ()
void	gather_inputs (Value *v)
void	add_listener (IisCell *who)
void	del_listener (IisCell *who)
void	mark_inputs (bool add)
void	clear_inputs ()
void	set_inputs ()
void	updated ()
void	value_changed ()
void	formule_changed ()
void	show_status_changed ()
void	recalc_changed ()
void	entered_changed ()
Value *	evaluate (Value *what)
Value *	lookup (Reference *var)
Value *	lookup (Range *var)
Value *	fetch_value ()
Value *	apply (Expression *what)
Private Attributes
Place< QString >	entered
Place< Value * >	formule
Place< Value * >	value
Place< QImage >	image
Place< bool >	show_status
Place< QString >	show
int	scale_xs
int	scale_ys
QImage	scaled
list< IisCell * >	listeners
list< IisCell * >	inputs
Place< bool >	needs_recalculation
bool	user_input_allowed
Friends
class	CallMember

---

Detailed Description

The IisCell class represents one specific cell in a spreadsheet. A cell does have a list of listeners to which notifications of its calculated value are notified. Cells works asynchrnously: they report request for calculation towards the spreadsheet who will come back with a recalc order somewhere in the future. The typical workflow of a spreadcell is a) entereing of a formule (the entered place). b) parsing the formule (the formule place). c) queueing a recalculation request. d) recalculating the variable and updating the value (the value place). e) updating the visualisation and informing all listeners)

Definition at line 25 of file iiscell.h.

---

Member Typedef Documentation

typedef void(IisCell::* IisCell::member)()

Definition at line 29 of file iiscell.h.

---

Constructor & Destructor Documentation

IisCell::IisCell (  QTable *  table, EditType  et )

Initializes the IisCell into the table entered is set to "", the formule and value are NULL, the needs_recalculation flag and user_input_allowed flags are false. The original and scaled images are empty and the show_status flag is true. Worwrapping is set on. Definition at line 102 of file iiscell.cpp. References entered, entered_changed(), flushCalls(), formule, formule_changed(), image, image_changed(), link(), needs_recalculation, recalc_changed(), scale_xs, scale_ys, scaled, show, show_changed(), show_status, show_status_changed(), user_input_allowed, value, value_changed(), and visual_changed(). : 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(); };

---

Member Function Documentation

void IisCell::add_listener (  IisCell *  who  )  [private]

To attach a new listener to this cell Definition at line 172 of file iiscell.cpp. References listeners. { for(list<IisCell*>::iterator it=listeners.begin() ; it!=listeners.end() ; it++) { IisCell * c = *it; if (c==who) return; } listeners.push_back(who); }

Value * IisCell::apply (  Expression *  what  )  [private]

The applciation step in the evaluator Definition at line 670 of file iiscell.cpp. References Runtime::apply(), Expression::argc(), Expression::argv(), evaluate(), Expression::op(), and runtime. Referenced by evaluate(). { 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); }

bool IisCell::can_be_calculated_now (   )

returns true if all the inputs provide a good value and none of them are scheduled for recalculation. For cells that require user_input in a situation where it is not allowed, this function returns false. Definition at line 544 of file iiscell.cpp. References inputs. { // 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::clear_inputs (   )  [private]

Will remove all the cells to which we are listening now Definition at line 484 of file iiscell.cpp. References inputs, and mark_inputs(). Referenced by formule_changed(). { mark_inputs(false); inputs.clear(); }

void IisCell::colsInserted (  int  col, int  nr )

When columns are inserted, the spreadtable will move them around. Afterwards all cells will be notified of the change and can change their formules as necessary. Definition at line 258 of file iiscell.cpp. References ValueCopier::copy(), and formule. { if (formule) { CellRightShifter shifter(col,nr); shifter.copy(formule); } }

QWidget * IisCell::createEditor (   )  const

Creates the editor when text is entered. Closely related to Qt functionality. (See over there) Definition at line 164 of file iiscell.cpp. References entered. { QWidget * res = QTableItem::createEditor(); QLineEdit * le = (QLineEdit*)(void*)res; le->setText(entered); return le; };

void IisCell::del_listener (  IisCell *  who  )  [private]

To delete a listener from this cell Definition at line 203 of file iiscell.cpp. References listeners. { for(list<IisCell*>::iterator it=listeners.begin() ; it!=listeners.end() ; it++) if ((*it)==who) { listeners.erase(it); return; } }

void IisCell::entered_changed (   )  [private]

Will try to set the formule according to the entered text. A parse error will propagate as error value. Definition at line 296 of file iiscell.cpp. References entered, ParseText::expr(), formule, and value. Referenced by IisCell(). { QString e = entered; if (e.isEmpty()) formule = NULL; else { try { ParseText p(e); formule = p.expr(); } catch (Error * p) { formule = NULL; value = p; } } }

Value * IisCell::evaluate (  Value *  what  )  [private]

evaluates the given expression, recursively, taking into account the user_input_allowed variable. Definition at line 651 of file iiscell.cpp. References apply(), and lookup(). Referenced by apply(), and recalc(). { 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::fetch_value (   )  [private]

the routine other cells use to obtain a value out of this cell. It returns NULL whenever the cell requires recalculation, or whenever the cell is showing an error value. Otherwise it returns the content of the value place. Definition at line 337 of file iiscell.cpp. References needs_recalculation, and value. Referenced by lookup(). { 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::flushCalls (   )  [private]

Definition at line 84 of file iiscell.cpp. References queued_calls. Referenced by IisCell(), load(), mark_recalc(), recalc(), and setText(). { 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; }

void IisCell::formule_changed (   )  [private]

If the formule changes, we clear all the old inputs, set all the new inputs. Try to figure out whether we will loop (if we do we set an error value). If we don't loop we request a recalculation of this cell, using mark_recalc. Definition at line 316 of file iiscell.cpp. References clear_inputs(), entered, formule, mark_recalc(), set_inputs(), Value::toString(), value, and will_loop(). Referenced by IisCell(). { 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(); }

void IisCell::gather_inputs (  Value *  v  )  [private]

This routine will find all the cells refered to directly or indirectly in v and add them to the inputs variable. This function does not clear the old inputs set. Definition at line 496 of file iiscell.cpp. References Expression::argc(), Expression::argv(), Reference::column, SpreadSheetTable::findItem(), Range::from, inputs, and Reference::row. Referenced by set_inputs(). { 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); }

QString IisCell::getFormuleTextForCell (  int  x, int  y )

returns the pretty-print version of the formule. This is necessary when shifting cells around. Definition at line 283 of file iiscell.cpp. References ValueCopier::copy(), formule, and Value::toString(). { if (!formule) return ""; RelativeShifter shifter(x-col(),y-row()); return shifter.copy(formule)->toString(); }

void IisCell::image_changed (   )  [private]

If the image changes then the scaled image will be cleared. If the new image is non empty then the show place is set to zero. Definition at line 182 of file iiscell.cpp. References image, scaled, and show. Referenced by IisCell(). { QImage I = image; scaled = QImage(); if (!I.isNull()) show = NULL; }

void IisCell::link (  AbstractPlace &  , member  )  [private]

Some variables in this class are 'places'. A place will automatically call a specific member when its value changes (and only when its value changes). This function provides the link between the place and the member call. Definition at line 70 of file iiscell.cpp. References CallMember. Referenced by IisCell(). { CallMember * em; em = new CallMember(*this,m); l.notify(em); };

void IisCell::load (  Data  data  )

Takes all information from the data field. All references to files are read as well. Definition at line 134 of file iiscell.cpp. References entered, flushCalls(), formule, Value::load(), set_inputs(), and value. Referenced by SpreadSheetTable::loadFile(). { 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(); };

Value * IisCell::lookup (  Range *  var  )  [private]

looks up a range of cells referenced by var. All the values are sequentially placed into a ValueArray. Definition at line 630 of file iiscell.cpp. References Reference::column, fetch_value(), Range::from, Reference::row, ValueArray::set(), and Range::to. { 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::lookup (  Reference *  var  )  [private]

looks up a value in the cell references to by var. Definition at line 621 of file iiscell.cpp. References Reference::column, fetch_value(), and Reference::row. Referenced by evaluate(). { 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(); }

void IisCell::mark_allow_ui (   )

sets the user_input_allowed flag to true Definition at line 478 of file iiscell.cpp. References needs_user_input(), and user_input_allowed. Referenced by SpreadSheetTable::status_selection(). { if (needs_user_input()) user_input_allowed=true; }

void IisCell::mark_inputs (  bool  add  )  [private]

This function will go through all the cells from which we would like to have notification and either request those cells to add or remove ourselve from the notification list. The add field determines whether it is add or delete Definition at line 559 of file iiscell.cpp. References inputs. Referenced by clear_inputs(), and set_inputs(). { 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); } }

void IisCell::mark_recalc (   )

Called from our notifying cells when a change to their value occurs. Internally called when the formule changed. Definition at line 472 of file iiscell.cpp. References flushCalls(), and needs_recalculation. Referenced by formule_changed(), and SpreadSheetTable::status_selection(). { needs_recalculation = true; flushCalls(); }

bool IisCell::needs_user_input (   )

determines whether user input is necessary for this cell Definition at line 539 of file iiscell.cpp. References formule, Runtime::requires_user_input(), and runtime. Referenced by mark_allow_ui(), and paint(). { return runtime.requires_user_input(formule); }

void IisCell::paint (  QPainter *  p, const QColorGroup &  cg, const QRect &  cr, bool  selected )  [virtual]

paints the cell either using the image, or using the text. if the text is used, the standard QTableItem is used to draw the text, if the image should be shown, we do it ourselve by either retrieving the scaled image, or, if it does not exist, creating the scaled image. The image is scaled such that its aspect ratio is preserved but that it will always fit entirely into the cell. The sides of the cell are colored using the current status information. deep red is a parse error, light red is an evaluation error, orange is a cell the rquires user input and does not have a value, yellow is a cell that requires user input and does have a avlue. Grey is for cells that show either the entered text or are recalculation at the moment. Green cells are ceel that require user input and do not have any value but are allowed to take input. Definition at line 391 of file iiscell.cpp. References image, needs_recalculation, needs_user_input(), show_status, user_input_allowed, and value. { // 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::queueCall (  CallMember *  m  )  [private]

Definition at line 79 of file iiscell.cpp. References queued_calls. Referenced by CallMember::setChanged(). { queued_calls.push_back(m); }

void IisCell::recalc (   )

recalc will evaluate the formule (if there is one) and set the value place (this can be an Error value as well). show_status is reset to false. This function should never be called directly. Instead use mark_recalc. Definition at line 597 of file iiscell.cpp. References evaluate(), flushCalls(), formule, needs_recalculation, show_status, user_input_allowed, and value. { 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(); }

void IisCell::recalc_changed (   )  [private]

When there is a need for recalculation (the needs_recalculation place set to true), then this function will set show_status to true (during recalculation we want to show the formule being calculated) and request the table to recalculate this cell somewhere later on. The actual recalculation occurs in recalc(). Definition at line 458 of file iiscell.cpp. References needs_recalculation, SpreadSheetTable::queue_recalculation(), show_status, updated(), and value. Referenced by IisCell(). { 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::rowsInserted (  int  row, int  nr )

When a rows are inserted, the spreadtable will move them around. Afterwards all cells will be notified of the change and can change their formules as necessary. Definition at line 249 of file iiscell.cpp. References ValueCopier::copy(), and formule. { if (formule) { CellDownShifter shifter(row,nr); shifter.copy(formule); } }

Data IisCell::saveFile (  QString  prefix  )

Returns a data representation of this cell. Image information will be stored in a seperate file prefixed with the prefix string. The prefix should be a path ending with "/" Definition at line 151 of file iiscell.cpp. References entered, formule, Value::getSaveDescription(), and value. Referenced by SpreadSheetTable::saveFile(). { 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; }

void IisCell::set_inputs (   )  [private]

Will gather all the inputs in the current formule and subscribe to all the cells we are taking values from Definition at line 490 of file iiscell.cpp. References formule, gather_inputs(), and mark_inputs(). Referenced by formule_changed(), and load(). { gather_inputs(formule); mark_inputs(true); };

void IisCell::setText (  const QString &  str  )  [virtual]

Sets the entered place to the given string Definition at line 290 of file iiscell.cpp. References entered, and flushCalls(). { entered = str; flushCalls(); }

void IisCell::show_changed (   )  [private]

If the show place changes, then the underlying QTableItem is updated to reflect the new string. If the string is non-empty, then the image is cleared. Definition at line 190 of file iiscell.cpp. References image, and show. Referenced by IisCell(). { QString S = show; QTableItem::setText(S); if (!S.isEmpty()) image = QImage(); }

void IisCell::show_status_changed (   )  [private]

If the show_status place changes, we either update the show palce to reflect the entered text, or call show_value() to present the previous calculated value. Definition at line 383 of file iiscell.cpp. References entered, show, show_status, and show_value(). Referenced by IisCell(). { if (show_status) show = entered; else show_value(); }

void IisCell::show_value (   )  [private]

If the value is zero, we reset show_status to true. Otherwise we figure out whether we should set the image place (when the value is an image) or the show place (when the value can be presented textual). Definition at line 367 of file iiscell.cpp. References image, show, show_status, and value. Referenced by show_status_changed(), and value_changed(). { 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::updated (   )  [private]

Will notify to all our listeners that we provide a new value. All subscribed listeners are contacted with mark_recalc() Definition at line 349 of file iiscell.cpp. References listeners. Referenced by recalc_changed(), and value_changed(). { 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 (   )  [private]

When a value changes, we update the visualized information through a call to show_value. Afterwards we call updated to notify all interested cells. Definition at line 360 of file iiscell.cpp. References show_status, show_value(), and updated(). Referenced by IisCell(). { if (!show_status) show_value(); updated(); }

void IisCell::visual_changed (   )  [private]

This function will ask the table to repaint this cell. Definition at line 198 of file iiscell.cpp. Referenced by IisCell(). { table()->updateCell(row(),col()); }

bool IisCell::will_influence (  IisCell *   )  [protected]

part of the loop detection routine Definition at line 584 of file iiscell.cpp. References listeners. { 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; }

bool IisCell::will_loop (   )  [protected]

part of the loop detection routine Definition at line 572 of file iiscell.cpp. References listeners. Referenced by formule_changed(). { 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; };

---

Friends And Related Function Documentation

friend class CallMember [friend]

Definition at line 27 of file iiscell.h. Referenced by link().

---

Member Data Documentation

Place<QString> IisCell::entered [private]

The text entered by the user. When this value changes show_status_changed and entered_changed will be called Definition at line 44 of file iiscell.h. Referenced by createEditor(), entered_changed(), formule_changed(), IisCell(), load(), saveFile(), setText(), and show_status_changed().

Place<Value*> IisCell::formule [private]

When entered text is parsed properly. The formule will hold the parse tree. A change to the formule induces a call to formule_changed Definition at line 51 of file iiscell.h. Referenced by colsInserted(), entered_changed(), formule_changed(), getFormuleTextForCell(), IisCell(), load(), needs_user_input(), recalc(), rowsInserted(), saveFile(), and set_inputs().

Place<QImage> IisCell::image [private]

When a value is available that is an image, then the converted QImage of that value. This image is not scaled to the requested resolution. Whenever the image changes, the image_changed routine will be called and clear the shown place automatically. Furthermore visual_changed will be called as well. Definition at line 69 of file iiscell.h. Referenced by IisCell(), image_changed(), paint(), show_changed(), and show_value().

list<IisCell*> IisCell::inputs [private]

A list of cells from which we hope to receive notifications Definition at line 151 of file iiscell.h. Referenced by can_be_calculated_now(), clear_inputs(), gather_inputs(), and mark_inputs().

list<IisCell*> IisCell::listeners [private]

A list of listeners to this cell. Listeners will be notified whenever a change in our value occurs. Definition at line 146 of file iiscell.h. Referenced by add_listener(), del_listener(), updated(), will_influence(), and will_loop().

Place<bool> IisCell::needs_recalculation [private]

The needs recalcualtion flag is set from mark_recalc. When changed it will automatically call recalc_changed and visual_changed. Definition at line 221 of file iiscell.h. Referenced by fetch_value(), IisCell(), mark_recalc(), paint(), recalc(), and recalc_changed().

int IisCell::scale_xs [private]

scale_xs holds the size of the resized image (the scaled attribute) for visualisation in the size of the spreadcell. Definition at line 121 of file iiscell.h. Referenced by IisCell().

int IisCell::scale_ys [private]

scale_ys holds the size of the resized image (the scaled attribute) for visualisation in the size of the spreadcell. Definition at line 127 of file iiscell.h. Referenced by IisCell().

QImage IisCell::scaled [private]

The scaled image is a smoothly resized image of the full resolution image. Its size is not necessarily the same as scale_xs and scale_ys. Those two variables define the box in which the scaled image should fit, without changing the aspect ratio. As soon as the size of the spreadcell changes will we update this field. This happens in the repaint operation. The scaled image (contrary to the original image) also includes the visualized coordinate system. Definition at line 138 of file iiscell.h. Referenced by IisCell(), and image_changed().

Place<QString> IisCell::show [private]

Show contains the string that should be shown in the spreadcell either as value (show_status == false) or as original entered text (show_status == true). If the show place is changed, then the image value will be cleared automatically (unless the show string becomes NULL, then the image place is not touched). Furthermore a call to visual_changed will take palce. Definition at line 89 of file iiscell.h. Referenced by IisCell(), image_changed(), show_changed(), show_status_changed(), and show_value().

Place<bool> IisCell::show_status [private]

Sometimes the status must be shown such as during calculation, when no decent value can be shown (e.g: NULL), or whenever the cell is not allowed to ask questions to the user. show_status is true whenever the original entered formule should be shown, otherwise it is false. A change to the show_status induces a call to show_status_changed. Definition at line 79 of file iiscell.h. Referenced by IisCell(), paint(), recalc(), recalc_changed(), show_status_changed(), show_value(), and value_changed().

bool IisCell::user_input_allowed [private]

This bariable is set whener the evaluator can present pop up boxes of all kinds to the user. Normally this is disabled as to not interrupt the user. Definition at line 243 of file iiscell.h. Referenced by IisCell(), mark_allow_ui(), paint(), and recalc().

Place<Value*> IisCell::value [private]

When the formule is evaluated, the value place will hold the resulting value. A change to this palce results in calls to value_changed. Whenever the value changes all listeners are informed. Definition at line 59 of file iiscell.h. Referenced by entered_changed(), fetch_value(), formule_changed(), IisCell(), load(), paint(), recalc(), recalc_changed(), saveFile(), and show_value().

---

The documentation for this class was generated from the following files:

• iiscell.h
• iiscell.cpp

---