COPASI API  4.16.103
Public Slots | Signals | Public Member Functions | Public Attributes | Protected Attributes | Private Slots | Static Private Member Functions | Private Attributes | List of all members
ParameterTable Class Reference

#include <parametertable.h>

Inheritance diagram for ParameterTable:
Inheritance graph
[legend]
Collaboration diagram for ParameterTable:
Collaboration graph
[legend]

Public Slots

void updateTable (const CReactionInterface &ri, const CReaction *mpReaction)
 

Signals

void parameterStatusChanged (int, bool)
 
void signalChanged (int, int, QString)
 

Public Member Functions

void initTable ()
 
 ParameterTable (QWidget *parent=0)
 

Public Attributes

std::vector< size_t > mIndex2Line
 
std::vector< size_t > mLine2Index
 

Protected Attributes

CQComboDelegatempComboDelegate
 

Private Slots

void handleCurrentCell (int row, int col, int, int)
 
void slotCellChanged (int row, int col)
 

Static Private Member Functions

static QStringList getListOfAllCompartmentNames (const CModel &model)
 
static QStringList getListOfAllGlobalParameterNames (const CModel &model)
 
static const std::vector
< std::string > 
getListOfAllMetabNames (const CModel &model, const CReactionInterface &ri)
 

Private Attributes

QStringList mGlobalParameters
 
QStringList mModifiers
 
int mOldRow
 
QStringList mProducts
 
QStringList mSubstrates
 
QStringList mVolumes
 

Detailed Description

Definition at line 54 of file parametertable.h.

Constructor & Destructor Documentation

ParameterTable::ParameterTable ( QWidget *  parent = 0)

Definition at line 30 of file parametertable.cpp.

References initTable(), parameterStatusChanged(), signalChanged(), and slotCellChanged().

31  : QTableWidget(parent),
32  mOldRow(0)
33 {
34  initTable();
35 
36  connect(this, SIGNAL(cellChanged(int, int)),
37  this, SLOT(slotCellChanged(int, int)));
38 
39  connect(this, SIGNAL(signalChanged(int, int, QString)),
40  parent, SLOT(slotTableChanged(int, int, QString)));
41 
42  connect(this, SIGNAL(parameterStatusChanged(int, bool)),
43  parent, SLOT(slotParameterStatusChanged(int, bool)));
44 }
void parameterStatusChanged(int, bool)
void signalChanged(int, int, QString)
void slotCellChanged(int row, int col)

Member Function Documentation

QStringList ParameterTable::getListOfAllCompartmentNames ( const CModel model)
staticprivate

Definition at line 143 of file parametertable.cpp.

References FROM_UTF8, CModel::getCompartments(), CCopasiObject::getObjectName(), and CCopasiVector< T >::size().

Referenced by updateTable().

144 {
145  QStringList ret;
146 
147  ret += "unknown";
148 
149  //all the global paramters in the model
150  size_t i, imax = model.getCompartments().size();
151 
152  for (i = 0; i < imax; ++i)
153  ret += FROM_UTF8(model.getCompartments()[i]->getObjectName());
154 
155  return ret;
156 }
#define FROM_UTF8(__x)
Definition: qtUtilities.h:73
const std::string & getObjectName() const
virtual size_t size() const
CCopasiVectorNS< CCompartment > & getCompartments()
Definition: CModel.cpp:1145
QStringList ParameterTable::getListOfAllGlobalParameterNames ( const CModel model)
staticprivate

Definition at line 127 of file parametertable.cpp.

References FROM_UTF8, CModel::getModelValues(), CModel::getNumModelValues(), and CCopasiObject::getObjectName().

Referenced by updateTable().

128 {
129  QStringList ret;
130 
131  ret += "unknown";
132 
133  //all the global paramters in the model
134  size_t i, imax = model.getNumModelValues();
135 
136  for (i = 0; i < imax; ++i)
137  ret += FROM_UTF8(model.getModelValues()[i]->getObjectName());
138 
139  return ret;
140 }
#define FROM_UTF8(__x)
Definition: qtUtilities.h:73
const std::string & getObjectName() const
const CCopasiVectorN< CModelValue > & getModelValues() const
Definition: CModel.cpp:1060
size_t getNumModelValues() const
Definition: CModel.cpp:1139
const std::vector< std::string > ParameterTable::getListOfAllMetabNames ( const CModel model,
const CReactionInterface ri 
)
staticprivate

Definition at line 57 of file parametertable.cpp.

References CMetabNameInterface::getDisplayName(), CReactionInterface::getListOfMetabs(), CModel::getMetabolites(), CFunctionParameter::MODIFIER, CFunctionParameter::PRODUCT, CCopasiVector< T >::size(), CFunctionParameter::SUBSTRATE, and CMetabNameInterface::unQuote().

Referenced by updateTable().

59 {
60  std::vector<std::string> ret;
61 
62  ret.push_back("unknown");
63 
64  //first all the metabs in the model
65  size_t i, imax = model.getMetabolites().size();
66 
67  for (i = 0; i < imax; ++i)
68  ret.push_back(CMetabNameInterface::getDisplayName(&model, *model.getMetabolites()[i], false));
69 
70  //now all the metabs from the ReactionInterface (that have not yet been committed to the model)
71  std::vector<std::string> lll;
72  std::vector<std::string>::const_iterator sourceIt, sourceItEnd;
73  std::vector<std::string>::const_iterator searchIt, searchItEnd;
74 
76  sourceItEnd = lll.end();
77 
78  for (sourceIt = lll.begin(); sourceIt != sourceItEnd; ++sourceIt)
79  {
80  std::string Source = CMetabNameInterface::unQuote(*sourceIt);
81  searchItEnd = ret.end();
82 
83  for (searchIt = ret.begin(); searchIt != searchItEnd; ++searchIt)
84  if (*searchIt == Source)
85  break;
86 
87  if (searchIt == searchItEnd) //that means new metab name is not in model yet
88  ret.push_back(Source);
89  }
90 
92  sourceItEnd = lll.end();
93 
94  for (sourceIt = lll.begin(); sourceIt != sourceItEnd; ++sourceIt)
95  {
96  std::string Source = CMetabNameInterface::unQuote(*sourceIt);
97  searchItEnd = ret.end();
98 
99  for (searchIt = ret.begin(); searchIt != searchItEnd; ++searchIt)
100  if (*searchIt == Source)
101  break;
102 
103  if (searchIt == searchItEnd) //that means new metab name is not in model yet
104  ret.push_back(Source);
105  }
106 
108  sourceItEnd = lll.end();
109 
110  for (sourceIt = lll.begin(); sourceIt != sourceItEnd; ++sourceIt)
111  {
112  std::string Source = CMetabNameInterface::unQuote(*sourceIt);
113  searchItEnd = ret.end();
114 
115  for (searchIt = ret.begin(); searchIt != searchItEnd; ++searchIt)
116  if (*searchIt == Source)
117  break;
118 
119  if (searchIt == searchItEnd) //that means new metab name is not in model yet
120  ret.push_back(Source);
121  }
122 
123  return ret;
124 }
const CCopasiVector< CMetab > & getMetabolites() const
Definition: CModel.cpp:1051
static std::string unQuote(const std::string &displayName)
virtual size_t size() const
static std::string getDisplayName(const CModel *model, const std::string &key, const bool &quoted)
const std::vector< std::string > & getListOfMetabs(CFunctionParameter::Role role) const
void ParameterTable::handleCurrentCell ( int  row,
int  col,
int  ,
int   
)
privateslot

Definition at line 473 of file parametertable.cpp.

References mIndex2Line, and mOldRow.

474 {
475  bool changed = false;
476 
477  size_t i, imax = mIndex2Line.size();
478 
479  for (i = 0; i < imax; ++i)
480  if ((int) mIndex2Line[i] - 1 == row)
481  {
482  changed = true;
483  if ((mOldRow < row) || (row == 0)) ++row; else --row;
484 
485  break;
486  }
487 
488  if (col > 3) {changed = true; col = 3;}
489 
490  if (col < 2) {changed = true; col = 2;}
491 
492  mOldRow = row;
493 
494  if (changed) setCurrentCell(row, col);
495 
496  //TODO: allow keyboard editing of col 2
497 }
std::vector< size_t > mIndex2Line
void ParameterTable::initTable ( )

Definition at line 46 of file parametertable.cpp.

References mpComboDelegate.

Referenced by ParameterTable().

47 {
48  setRowCount(0);
49  setSelectionMode(QTableWidget::NoSelection);
50 
51  mpComboDelegate = new CQComboDelegate(NULL, this);
52  setItemDelegateForColumn(2, mpComboDelegate);
53 
54  setShowGrid(false);
55 }
CQComboDelegate * mpComboDelegate
void ParameterTable::parameterStatusChanged ( int  ,
bool   
)
signal

Referenced by ParameterTable(), and slotCellChanged().

void ParameterTable::signalChanged ( int  ,
int  ,
QString   
)
signal

Referenced by ParameterTable(), and slotCellChanged().

void ParameterTable::slotCellChanged ( int  row,
int  col 
)
privateslot

Definition at line 499 of file parametertable.cpp.

References C_INVALID_INDEX, CQComboDelegate::getItems(), mIndex2Line, mpComboDelegate, parameterStatusChanged(), and signalChanged().

Referenced by ParameterTable().

500 {
501  if (col != 2 && col != 3) return; //Other cols shouldn't change, anyway.
502 
503  size_t i, imax = mIndex2Line.size();
504 
505  for (i = imax - 1; i != C_INVALID_INDEX; --i)
506  if ((int) mIndex2Line[i] <= row) break;
507 
508  QString newVal = item(row, col)->text();
509 
510  QStringList comboList = *mpComboDelegate->getItems(row);
511 
512  if (col == 2 && comboList[0] == "--local--") //is Parameter
513  {
514  emit parameterStatusChanged((int) i, (newVal == "--local--"));
515 
516  if (newVal == "--local--")
517  newVal = "0"; // item(row, 3)->text();
518  }
519 
520  emit signalChanged((int) i, row - (int) mIndex2Line[i], newVal);
521 }
void parameterStatusChanged(int, bool)
std::vector< size_t > mIndex2Line
#define C_INVALID_INDEX
Definition: copasi.h:222
const QStringList * getItems(int row) const
CQComboDelegate * mpComboDelegate
void signalChanged(int, int, QString)
void ParameterTable::updateTable ( const CReactionInterface ri,
const CReaction mpReaction 
)
slot

Definition at line 158 of file parametertable.cpp.

References CModel::dimensionlessArea, CModel::dimensionlessLength, CModel::dimensionlessQuantity, CModel::dimensionlessTime, CModel::dimensionlessVolume, CModelEntity::FIXED, FROM_UTF8, CKeyFactory::get(), CModel::getAreaUnitEnum(), CReactionInterface::getChemEqInterface(), CReactionInterface::getFunction(), CModelEntity::getInitialValue(), CCopasiRootContainer::getKeyFactory(), CModel::getLengthUnitEnum(), getListOfAllCompartmentNames(), getListOfAllGlobalParameterNames(), getListOfAllMetabNames(), CReactionInterface::getListOfMetabs(), CReactionInterface::getLocalValue(), CReactionInterface::getMapping(), CReactionInterface::getMappings(), CChemEqInterface::getMolecularity(), CCopasiObject::getObjectAncestor(), CCopasiObject::getObjectDataModel(), CReaction::getParameterMapping(), CReactionInterface::getParameterName(), CModel::getQuantityUnitEnum(), CModelEntity::getStatus(), CModel::getTimeUnitEnum(), CReactionInterface::getUsage(), CModel::getVolumeUnitEnum(), CQIconResource::icon(), CReactionInterface::isLocalValue(), CReactionInterface::isLocked(), CReactionInterface::isMulticompartment(), CReactionInterface::isVector(), CQIconResource::locked, mGlobalParameters, mIndex2Line, mLine2Index, mModifiers, CFunctionParameter::MODIFIER, mpComboDelegate, mProducts, mSubstrates, mVolumes, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CQIconResource::reactionModifier, CQIconResource::reactionProduct, CQIconResource::reactionSubstrate, CFunctionParameter::RoleNameDisplay, CQComboDelegate::setItems(), CFindDimensions::setUseHeuristics(), CReactionInterface::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CQIconResource::unlocked, CMetabNameInterface::unQuote(), CFunctionParameter::VARIABLE, vectorOfStrings2QStringList(), and CFunctionParameter::VOLUME.

159 {
160  blockSignals(true); // So cellChanged doesn't fire when items are set.
161 
162  setRowCount(0);
163 
164  if (pReaction == NULL) return;
165 
166  CModel * pModel = dynamic_cast< CModel * >(pReaction->getObjectAncestor("Model"));
167 
168  //first get the units strings
174  );
175  units.setUseHeuristics(true);
176  units.setMolecularitiesForMassAction(ri.getChemEqInterface().getMolecularity(CFunctionParameter::SUBSTRATE),
178  units.findDimensions(ri.isMulticompartment());
179 
181 
182  // Load the comboDelegate lists
183  mGlobalParameters.clear();
185 
186  if (mGlobalParameters.indexOf("--local--") != -1) // in case someone names a parameter "--local--"
187  mGlobalParameters.replace(mGlobalParameters.indexOf("--local--"), "\"--local--\"");
188 
189  mGlobalParameters.push_front("--local--");
190 
191  std::vector<std::string>::const_iterator it;
192 
193  mSubstrates.clear();
195 
196  for (it = ri.getListOfMetabs(usage).begin(); it != ri.getListOfMetabs(usage).end(); ++it)
198 
199  mProducts.clear();
201 
202  for (it = ri.getListOfMetabs(usage).begin(); it != ri.getListOfMetabs(usage).end(); ++it)
204 
205  mModifiers.clear(); // Get all metabs; modifiers are never locked
207 
208  mVolumes.clear();
210 
211  size_t i, imax = ri.size();
212  size_t j, jmax;
213  size_t rowCounter = 0;
214 
215  QTableWidgetItem *pItem = NULL;
216 
217  QColor subsColor(255, 210, 210);
218  QColor prodColor(210, 255, 210);
219  QColor modiColor(250, 250, 190);
220  QColor paraColor(210, 210, 255);
221  QColor volColor(210, 210, 255);
222  QColor timeColor(210, 210, 210);
223 
224  QString qUsage;
225  bool locked = false;
226  QColor color;
227  const std::vector<std::string> * metabNames;
228 
229  mIndex2Line.resize(imax);
230  mLine2Index.clear();
231 
232  setRowCount((int) imax);
233 
234  for (i = 0; i < imax; ++i)
235  {
236  mIndex2Line[i] = rowCounter;
237 
238  // set the stuff that is different for the specific usages
239  usage = ri.getUsage(i);
241  locked = ri.isLocked(i);
242 
243  switch (usage)
244  {
246  color = subsColor;
247  break;
248 
250  color = prodColor;
251  break;
252 
254  color = modiColor;
255  break;
256 
258  color = paraColor;
259  break;
260 
262  color = volColor;
263  break;
264 
266  color = timeColor;
267  break;
268 
270  color = QColor(255, 20, 20);
271  break;
272 
273  default :
274  qUsage = "unknown";
275  color = QColor(255, 20, 20);
276  break;
277  }
278 
279  // add first column
280  pItem = new QTableWidgetItem(qUsage);
281  pItem->setBackground(color);
282 
283  if (usage == CFunctionParameter::SUBSTRATE)
285  else if (usage == CFunctionParameter::PRODUCT)
287  else if (usage == CFunctionParameter::MODIFIER)
289 
290  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
291  setItem((int) rowCounter, 0, pItem);
292 
293  // add second column
294  pItem = new QTableWidgetItem(FROM_UTF8(ri.getParameterName(i)));
295  pItem->setBackground(color);
296 
297  if ((usage != CFunctionParameter::PARAMETER)
298  && (usage != CFunctionParameter::VOLUME)
299  && (usage != CFunctionParameter::TIME))
300  {
301  if (locked)
303  else
305  }
306 
307  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
308  setItem((int) rowCounter, 1, pItem);
309 
310  // add units column
311  const CCopasiDataModel* pDataModel = pModel->getObjectDataModel();
312 
313  if (pDataModel == NULL) return;
314 
315  QString theseUnits = FROM_UTF8(" " + units.getDimensions()[i].getDisplayString(pModel));
316  pItem = new QTableWidgetItem(theseUnits);
317  pItem->setBackgroundColor(color);
318  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
319  setItem((int) rowCounter, 4, pItem);
320 
321  // Create and color Value column
322  pItem = new QTableWidgetItem("");
323  pItem->setBackground(QColor(color));
324  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
325  setItem((int) rowCounter, 3, pItem);
326 
327  // add fourth (Mapping) column (col index = 3)
328  pItem = new QTableWidgetItem("");
329  pItem->setBackground(color);
330  setItem((int) rowCounter, 2, pItem);
331 
332  // if line is for a metabolite Parameter . . .
333  if ((usage == CFunctionParameter::SUBSTRATE)
334  || (usage == CFunctionParameter::PRODUCT)
335  || (usage == CFunctionParameter::MODIFIER))
336  {
337 
338  metabNames = &(ri.getMappings(i));
339 
340  if (locked)
341  {
342  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
343  closePersistentEditor(pItem);
344  }
345  else
346  {
347  if (usage == CFunctionParameter::SUBSTRATE)
348  mpComboDelegate->setItems(rowCounter, &mSubstrates);
349  else if (usage == CFunctionParameter::PRODUCT)
350  mpComboDelegate->setItems(rowCounter, &mProducts);
351  else // must be MODIFIER
352  {
353  mpComboDelegate->setItems(rowCounter, &mModifiers);
354  }
355 
356  openPersistentEditor(pItem);
357  }
358 
359  if (!ri.isVector(i))
360  pItem->setText(FROM_UTF8(CMetabNameInterface::unQuote((*metabNames)[0])));
361  else
362  {
363  if (locked)
364  pItem->setText("");
365  else // this should not happen
366  pItem->setText("add species");
367 
368  // add lines for vector parameters
369  jmax = metabNames->size();
370 
371  if (jmax > 0)
372  {
373  setRowCount(rowCount() + (int)(jmax - 1));
374 
375  item((int) rowCounter, 2)->setText(FROM_UTF8((*metabNames)[0]));
376 
377  for (j = 1; j < jmax; ++j)
378  {
379  ++rowCounter;
380 
381  for (int k = 0; k < 5; k++)
382  {
383  pItem = new QTableWidgetItem("");
384  pItem->setFlags(pItem->flags() & (~Qt::ItemIsEditable));
385  pItem->setBackgroundColor(color);
386  setItem((int) rowCounter, k, pItem);
387  }
388 
389  item((int) rowCounter, 2)->setText(FROM_UTF8((*metabNames)[j]));
390  item((int) rowCounter, 4)->setText(theseUnits);
391  }
392  }
393  }
394  }
395  // if line is for a kinetic parameter . . .
396  else if (usage == CFunctionParameter::PARAMETER)
397  {
399 
400  if (ri.isLocalValue(i))
401  {
402  pItem->setText("--local--");
403  }
404  else //global parameter
405  {
406  QString paramText = FROM_UTF8(ri.getMapping(i));
407 
408  if (paramText == "--local--")
409  paramText = "\"--local--\"";
410 
411  pItem->setText(paramText);
412  }
413 
414  openPersistentEditor(pItem);
415 
416  // add item to Value column
417  pItem = item((int) rowCounter, 3);
418 
419  if (ri.isLocalValue(i))
420  {
421  pItem->setText(QString::number(ri.getLocalValue(i)));
422  pItem->setFlags(pItem->flags() | (Qt::ItemIsEditable));
423  }
424  else
425  {
426  const std::vector<std::string> &mapping = pReaction->getParameterMapping(i);
427 
428  if (mapping.size() > 0)
429  {
430  std::string Key = mapping[0];
431 
432  const CModelValue * pParamObject =
433  dynamic_cast<const CModelValue *>(CCopasiRootContainer::getKeyFactory()->get(Key));
434 
435  if (pParamObject != NULL &&
436  pParamObject->getStatus() == CModelEntity::FIXED)
437  {
438  pItem->setText(QString::number(pParamObject->getInitialValue()));
439  pItem->setTextColor(QColor(Qt::darkGray));
440  }
441  }
442  }
443  }
444 
445  // if line is for a volume . . .
446  else if (usage == CFunctionParameter::VOLUME)
447  {
448  mpComboDelegate->setItems(rowCounter, &mVolumes);
449  pItem->setText(FROM_UTF8(ri.getMapping(i)));
450  openPersistentEditor(pItem);
451  }
452  // if line is for time . . .
453  else if (usage == CFunctionParameter::TIME)
454  {
455  pItem->setText("");
456  }
457  // if line is for an unknown role . . .
458  else
459  {
460  pItem->setText(QString::number(ri.getLocalValue(i)));
461  }
462 
463  resizeRowToContents((int) rowCounter);
464 
465  ++rowCounter;
466  }
467 
468  resizeColumnsToContents();
469 
470  blockSignals(false);
471 }
CCopasiDataModel * getObjectDataModel()
size_t getMolecularity(CFunctionParameter::Role role) const
std::string getParameterName(size_t index) const
CModel::AreaUnit getAreaUnitEnum() const
Definition: CModel.cpp:2198
#define FROM_UTF8(__x)
Definition: qtUtilities.h:73
static std::string unQuote(const std::string &displayName)
const std::vector< std::string > & getMappings(size_t index) const
const CChemEqInterface & getChemEqInterface() const
CModel::QuantityUnit getQuantityUnitEnum() const
Definition: CModel.cpp:2331
CCopasiObject * get(const std::string &key)
std::vector< size_t > mIndex2Line
static QStringList getListOfAllCompartmentNames(const CModel &model)
bool isVector(size_t index) const
void setUseHeuristics(bool flag)
Definition: CDimension.cpp:330
const CFunction * getFunction() const
static const std::vector< std::string > getListOfAllMetabNames(const CModel &model, const CReactionInterface &ri)
bool isLocked(size_t index) const
const C_FLOAT64 & getLocalValue(size_t index) const
std::vector< size_t > mLine2Index
const std::string & getMapping(size_t index) const
const C_FLOAT64 & getInitialValue() const
QStringList mGlobalParameters
CFunctionParameter::Role getUsage(size_t index) const
void vectorOfStrings2QStringList(std::vector< std::string > vs, QStringList &qsl)
static const QIcon & icon(const IconID &id)
CModel::LengthUnit getLengthUnitEnum() const
Definition: CModel.cpp:2220
CQComboDelegate * mpComboDelegate
CModel::TimeUnit getTimeUnitEnum() const
Definition: CModel.cpp:2243
static CKeyFactory * getKeyFactory()
const std::vector< std::string > & getListOfMetabs(CFunctionParameter::Role role) const
QStringList mModifiers
static const std::string RoleNameDisplay[]
void setItems(int row, const QStringList *pComboItems)
QStringList mProducts
Definition: CModel.h:50
size_t size() const
const CModelEntity::Status & getStatus() const
bool isLocalValue(size_t index) const
CModel::VolumeUnit getVolumeUnitEnum() const
Definition: CModel.cpp:2175
QStringList mVolumes
QStringList mSubstrates
static QStringList getListOfAllGlobalParameterNames(const CModel &model)
bool isMulticompartment() const

Member Data Documentation

QStringList ParameterTable::mGlobalParameters
private

Definition at line 78 of file parametertable.h.

Referenced by updateTable().

std::vector<size_t> ParameterTable::mIndex2Line

Definition at line 97 of file parametertable.h.

Referenced by handleCurrentCell(), slotCellChanged(), and updateTable().

std::vector<size_t> ParameterTable::mLine2Index

Definition at line 96 of file parametertable.h.

Referenced by updateTable().

QStringList ParameterTable::mModifiers
private

Definition at line 81 of file parametertable.h.

Referenced by updateTable().

int ParameterTable::mOldRow
private

Definition at line 93 of file parametertable.h.

Referenced by handleCurrentCell().

CQComboDelegate* ParameterTable::mpComboDelegate
protected

Definition at line 75 of file parametertable.h.

Referenced by initTable(), slotCellChanged(), and updateTable().

QStringList ParameterTable::mProducts
private

Definition at line 80 of file parametertable.h.

Referenced by updateTable().

QStringList ParameterTable::mSubstrates
private

Definition at line 79 of file parametertable.h.

Referenced by updateTable().

QStringList ParameterTable::mVolumes
private

Definition at line 82 of file parametertable.h.

Referenced by updateTable().


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