FunctionWidget1 Class Reference

A widget class for Functions branch. More...

#include <FunctionWidget1.h>

Inheritance diagram for FunctionWidget1:

Collaboration diagram for FunctionWidget1:

Public Member Functions
	FunctionWidget1 (QWidget *parent, const char *name=0, Qt::WFlags f=0)
virtual bool	leave ()
virtual bool	update (ListViews::ObjectType objectType, ListViews::Action action, const std::string &key)
	Function to update the COPASI widgets. More...
virtual	~FunctionWidget1 ()
	Destructor. More...
Public Member Functions inherited from CopasiWidget
	CopasiWidget (QWidget *parent=0, const char *name=0, Qt::WFlags f=0)
bool	enter (const std::string &key)
CCopasiDataModel *	getDataModel ()
bool	getIgnoreUpdates ()
virtual void	setFramework (int framework)
void	setIgnoreUpdates (bool v)

Protected Slots
void	slotBtnCopy ()
void	slotBtnDelete ()
	Slot for being activated whenever Delete button is clicked. More...
void	slotBtnNew ()
	Slot for being activated wehenver New button is clicked. More...
virtual void	slotFcnDescriptionChanged (bool)
	Slot for changing the function description. More...
virtual void	slotReversibilityChanged ()
	Slot for changing the reversibility of the function. More...
void	slotTableValueChanged (const QString &)
	Slot for changing the table value. More...
Protected Slots inherited from CopasiWidget
virtual bool	protectedNotify (ListViews::ObjectType objectType, ListViews::Action action, const std::string &key="")

Protected Member Functions
bool	copyFunctionContentsToFunction (const CFunction *src, CFunction *target)
virtual bool	enterProtected ()
bool	functionParametersChanged ()
bool	loadFromFunction (const CFunction *=NULL)
bool	loadParameterTable ()
bool	loadReversibility (TriLogic rev)
bool	loadUsageTable ()
	Function to generate the text representation of the usage restrictions. More...
bool	saveToFunction ()
void	updateApplication ()

Protected Attributes
bool	flagChanged
bool	isValid
bool	mIgnoreFcnDescriptionChange
CFunction *	mpFunction
Protected Attributes inherited from CopasiWidget
int	mFramework
bool	mIgnoreUpdates
std::string	mKey
CCopasiDataModel *	mpDataModel
ListViews *	mpListView
CCopasiObject *	mpObject

Private Member Functions
void	init ()

Private Attributes
std::string	mKeyToCopy
bool	mReadOnly

Detailed Description

A widget class for Functions branch.

This widget shows detailed description of an individual function

Definition at line 29 of file FunctionWidget1.h.

Constructor & Destructor Documentation

FunctionWidget1::FunctionWidget1	(	QWidget *	parent,
		const char *	name = 0,
		Qt::WFlags	f = 0
	)

Definition at line 49 of file FunctionWidget1.cpp.

References init().

                                                                                   :
  CopasiWidget(parent, name, fl),
  flagChanged(false),
  isValid(false),
  mIgnoreFcnDescriptionChange(false),
  mpFunction(NULL),
  mKeyToCopy("")
{
  setupUi(this);

  init();
}

FunctionWidget1::~FunctionWidget1 ( )

virtual

Destructor.

Definition at line 63 of file FunctionWidget1.cpp.

References mpFunction, and pdelete.

{
  //pdelete(mMmlWidget);
  //pdelete(mScrollView);
  pdelete(mpFunction);
}

Member Function Documentation

bool FunctionWidget1::copyFunctionContentsToFunction ( const CFunction *  src, CFunction *  target  )

protected

Definition at line 447 of file FunctionWidget1.cpp.

References CFunctionParameters::add(), C_INVALID_INDEX, CFunctionParameters::findParameterByName(), CEvaluationTree::getInfix(), CCopasiObject::getObjectName(), CFunction::getVariables(), CFunctionParameters::remove(), CFunction::setInfix(), and CFunctionParameters::size().

Referenced by saveToFunction().

{
  //Parameters
  CFunctionParameters &functParam = target->getVariables();
  const CFunctionParameters &pfunctParam = src->getVariables();
  CFunctionParameter::DataType Type;
  size_t index;
  size_t i, j;

  if (src->getInfix() != target->getInfix())
    target->setInfix(src->getInfix());

  for (i = 0; i < pfunctParam.size(); i++)
    {
      // check if function parameter exists in pFunctionParameter
      if ((index = functParam.findParameterByName(pfunctParam[i]->getObjectName(),
                   Type)) != C_INVALID_INDEX)
        // match found
        {
          if (functParam[index]->getUsage() != pfunctParam[i]->getUsage())
            {
              //changed = true;
              // update usage
              functParam[index]->setUsage(pfunctParam[i]->getUsage());
              //functParam[pfunctParam[i]->getObjectName()]->setUsage(functParam[i]->getUsage());
            }

          if (functParam[index]->getType() != pfunctParam[i]->getType())
            {
              //changed = true;
              // update type
              functParam[index]->setType(pfunctParam[i]->getType());
            }
        }
      else
        {
          // match not found
          //changed = true;
          functParam.add(*pfunctParam[i]);
        }
    }

  // remove extra parameters existing in functParam, compare functParam to pfunctParam
  if (pfunctParam.size() != functParam.size())
    {
      for (j = 0; j < functParam.size(); j++)
        {
          if ((index = pfunctParam.findParameterByName(functParam[j]->getObjectName(),
                       Type)) == C_INVALID_INDEX)
            // the lines below occurs if new functionParameter does not exist in pfunctParam
            {
              //changed = true;
              // remove the extra parameter in functParam
              functParam.remove(functParam[j]->getObjectName());
            }
        }
    } //TODO: this is probably much too complicated

  return true;
}

bool FunctionWidget1::enterProtected ( )

protectedvirtual

Reimplemented from CopasiWidget.

Definition at line 922 of file FunctionWidget1.cpp.

References CKeyFactory::get(), CCopasiRootContainer::getKeyFactory(), loadFromFunction(), mKeyToCopy, CopasiWidget::mpListView, CopasiWidget::mpObject, and ListViews::switchToOtherWidget().

{
  CFunction * func = NULL;

  if (mKeyToCopy != "")
    {
      func = dynamic_cast<CFunction*>(CCopasiRootContainer::getKeyFactory()->get(mKeyToCopy));
      mKeyToCopy = "";
    }
  else
    {
      func = dynamic_cast<CFunction*>(mpObject);
    }

  if (func)
    return loadFromFunction(func);

  mpListView->switchToOtherWidget(5, "");
  return false;
}

bool FunctionWidget1::functionParametersChanged ( )

protected

Definition at line 508 of file FunctionWidget1.cpp.

References CKeyFactory::get(), CCopasiRootContainer::getKeyFactory(), CFunction::getVariables(), CopasiWidget::mKey, and mpFunction.

Referenced by leave().

{
  CFunction* func = dynamic_cast<CFunction*>(CCopasiRootContainer::getKeyFactory()->get(mKey));

  if (!func) return false;

  return (!(func->getVariables() == mpFunction->getVariables()));
}

void FunctionWidget1::init ( )

private

Definition at line 70 of file FunctionWidget1.cpp.

References mpFunction, and slotFcnDescriptionChanged().

Referenced by FunctionWidget1().

{
  // change the default signal-slot connection
  // disconnect(mpExpressionEMSW->mpExpressionWidget,
  //            SIGNAL(textChanged()),
  //            mpExpressionEMSW->mpExpressionWidget,
  //            SLOT(slotTextChanged()));
  mpExpressionEMSW->mpExpressionWidget->setFunction("");
  connect(mpExpressionEMSW->mpExpressionWidget->getValidator(), SIGNAL(stateChanged(bool)), this, SLOT(slotFcnDescriptionChanged(bool)));

  // hide all unnecessary buttons
  mpExpressionEMSW->mpBtnExpressionObject->hide();
  // mpExpressionEMSW->mpBtnViewExpression->hide();

  // overwrite the tip
  mpExpressionEMSW->mpBtnSaveExpression->setToolTip(tr("save formula"));
  mpExpressionEMSW->mpBtnEditExpression->setToolTip(tr("edit formula"));

  mpFunction = NULL;
}

bool FunctionWidget1::leave ( )

virtual

Reimplemented from CopasiWidget.

Definition at line 753 of file FunctionWidget1.cpp.

References CFunctionDB::appendDependentFunctions(), CModel::appendDependentModelObjects(), FROM_UTF8, functionParametersChanged(), CKeyFactory::get(), CCopasiRootContainer::getDatamodelList(), CEvaluationTree::getDeletedObjects(), CCopasiRootContainer::getFunctionList(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CQMessageBox::information(), isValid, CopasiWidget::mKey, and saveToFunction().

{
  assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
  CModel * pModel = (*CCopasiRootContainer::getDatamodelList())[0]->getModel();

  if (pModel == NULL)
    return true;

  // :TODO: We should check what changes have been done to the function //
  CFunctionDB * pFunctionDB = CCopasiRootContainer::getFunctionList();

  if (pFunctionDB == NULL)
    return true;

  CEvaluationTree * pFunction = dynamic_cast<CEvaluationTree *>(CCopasiRootContainer::getKeyFactory()->get(mKey));

  if (pFunction == NULL)
    return true;

  bool Used = false;

  if (functionParametersChanged())
    {
      QString msg =
        QString("Cannot modify function: \n  %1\n").arg(FROM_UTF8(pFunction->getObjectName()));

      std::set< const CCopasiObject * > Functions;
      std::set< const CCopasiObject * > Reactions;
      std::set< const CCopasiObject * > Metabolites;
      std::set< const CCopasiObject * > Values;
      std::set< const CCopasiObject * > Compartments;
      std::set< const CCopasiObject * > Events;

      std::set< const CCopasiObject * > DeletedObjects = pFunction->getDeletedObjects();

      Used |= pFunctionDB->appendDependentFunctions(DeletedObjects, Functions);

      if (Functions.size() > 0)
        {
          msg.append("Following functions(s) reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Functions.begin();
          std::set< const CCopasiObject * >::const_iterator end = Functions.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      Used |= pModel->appendDependentModelObjects(DeletedObjects, Reactions, Metabolites,
              Compartments, Values, Events);

      if (Reactions.size() > 0)
        {
          msg.append("Following reactions(s) reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Reactions.begin();
          std::set< const CCopasiObject * >::const_iterator end = Reactions.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      if (Metabolites.size() > 0)
        {
          msg.append("Following species reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Metabolites.begin();
          std::set< const CCopasiObject * >::const_iterator end = Metabolites.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      if (Values.size() > 0)
        {
          msg.append("Following global quantities reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Values.begin();
          std::set< const CCopasiObject * >::const_iterator end = Values.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      if (Compartments.size() > 0)
        {
          msg.append("Following compartment(s) reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Compartments.begin();
          std::set< const CCopasiObject * >::const_iterator end = Compartments.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      if (Events.size() > 0)
        {
          msg.append("Following event(s) reference above:\n  ");

          std::set< const CCopasiObject * >::const_iterator it = Events.begin();
          std::set< const CCopasiObject * >::const_iterator end = Events.end();

          for (; it != end; ++it)
            {
              msg.append(FROM_UTF8((*it)->getObjectName()));
              msg.append("\n  ");
            }

          msg.remove(msg.length() - 2, 2);
        }

      if (Used)
        {
          CQMessageBox::information(this, "Modification not possible",
                                    msg, QMessageBox::Ok, QMessageBox::Ok);

          return true;
        }
    }

  if (isValid)
    {
      saveToFunction();
      mpExpressionEMSW->updateWidget();
    }

  //update pFunction values

  /* Remove line breaks from the function description */
  /*std::string desc = TO_UTF8(textBrowser->text());
  unsigned int loc = 0;
  while (1)
    {
      loc = desc.find('\n', loc);
      if (loc == std::string::npos)
        break;
      desc.erase(loc, 1);
    }
  textBrowser->setText(FROM_UTF8(desc));*/

  //mScrollView->hide();
  return true;
}

bool FunctionWidget1::loadFromFunction ( const CFunction *  func = NULL )

protected

Definition at line 375 of file FunctionWidget1.cpp.

References CEvaluationTree::copy(), flagChanged, CEvaluationTree::getInfix(), CEvaluationTree::getType(), CFunction::isReversible(), CEvaluationTree::isUsable(), isValid, loadParameterTable(), loadReversibility(), loadUsageTable(), CEvaluationTree::MassAction, mIgnoreFcnDescriptionChange, mpFunction, mReadOnly, pdelete, and CEvaluationTree::PreDefined.

Referenced by enterProtected(), and update().

{
  if (func != NULL)
    {
      pdelete(mpFunction);
      mpFunction = dynamic_cast<CFunction *>(CEvaluationTree::copy(*func));
      flagChanged = false;
    }

  if (mpFunction == NULL)
    return false;

  // function name
  /* Insert line breaks in the function description */
  std::string desc = mpFunction->getInfix();
  size_t l = 0;
  size_t n = 0;
  size_t len = desc.length();

  while (len - l > 65)
    {
      n = l;
      l = l + 65;

      while (l > n)
        {
          char ch = desc.at(l);

          if ((ch == '+') || (ch == '-') || (ch == '*') || (ch == '/') || (ch == ',') || (ch == ' '))
            break;

          l--;
        }

      // We did not find a suitable place to break the line
      if (l == n) l += 65;

      desc.insert(l, 1, '\n');
    }

  mReadOnly = (mpFunction->getType() == CFunction::PreDefined ||
               mpFunction->getType() == CFunction::MassAction);

  RadioButton1->setEnabled(!mReadOnly);
  RadioButton2->setEnabled(!mReadOnly);
  RadioButton3->setEnabled(!mReadOnly);

  mpExpressionEMSW->setReadOnly(mReadOnly);

  // formula expression
  mIgnoreFcnDescriptionChange = true;
  mpExpressionEMSW->mpExpressionWidget->setFunction(mpFunction->getInfix());
  mIgnoreFcnDescriptionChange = false;

  mpExpressionEMSW->updateWidget();

  //radio buttons
  loadReversibility(mpFunction->isReversible());

  //parameter table
  loadParameterTable();

  // application table
  loadUsageTable(/*pFunction->getVariables().getUsageRanges()*/);

  isValid = mpFunction->isUsable();

  flagChanged = false;

  return true;
}

bool FunctionWidget1::loadParameterTable ( )

protected

Definition at line 91 of file FunctionWidget1.cpp.

References COL_NAME, COL_UNIT, COL_USAGE, CFunctionParameter::DataTypeName, CModel::dimensionlessArea, CModel::dimensionlessLength, CModel::dimensionlessQuantity, CModel::dimensionlessTime, CModel::dimensionlessVolume, FROM_UTF8, CModel::getAreaUnitEnum(), CCopasiRootContainer::getDatamodelList(), CModel::getLengthUnitEnum(), CCopasiDataModel::getModel(), CModel::getQuantityUnitEnum(), CModel::getTimeUnitEnum(), CFunction::getVariables(), CModel::getVolumeUnitEnum(), CFunctionParameter::MODIFIER, mpFunction, mReadOnly, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CFunctionParameter::RoleNameDisplay, CFindDimensions::setUseHeuristics(), CFunctionParameters::size(), slotTableValueChanged(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CFunctionParameter::VARIABLE, and CFunctionParameter::VOLUME.

Referenced by loadFromFunction(), slotFcnDescriptionChanged(), and slotTableValueChanged().

{
  QColor subsColor(255, 210, 210);
  QColor prodColor(210, 255, 210);
  QColor modiColor(250, 250, 190);
  QColor paraColor(210, 210, 255);
  QColor volColor(210, 210, 255);
  QColor timeColor(210, 210, 210);
  QColor color;

  size_t i, j;
  CFunctionParameters & params = mpFunction->getVariables();

  // list of usages for combobox
  QStringList Usages;

  for (i = 0; CFunctionParameter::RoleNameDisplay[i] != ""; i++)
    {
      if (dynamic_cast<CKinFunction *>(mpFunction) &&
          CFunctionParameter::VARIABLE == (CFunctionParameter::Role) i) continue;

      Usages += (FROM_UTF8(CFunctionParameter::RoleNameDisplay[i]));
    }

  //create list of data types (for combobox)
  QStringList functionType;

  for (i = 0; CFunctionParameter::DataTypeName[i] != ""; i++)
    functionType += (FROM_UTF8(CFunctionParameter::DataTypeName[i]));

  //find parameter units
  assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
  CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
  assert(pDataModel != NULL);
  CModel * pModel = pDataModel->getModel();
  assert(pModel != NULL);

  CFindDimensions ddd(mpFunction, pModel->getQuantityUnitEnum() == CModel::dimensionlessQuantity,
                      pModel->getVolumeUnitEnum() == CModel::dimensionlessVolume,
                      pModel->getTimeUnitEnum() == CModel::dimensionlessTime,
                      pModel->getAreaUnitEnum() == CModel::dimensionlessArea,
                      pModel->getLengthUnitEnum() == CModel::dimensionlessLength
                     );

  ddd.setUseHeuristics(true);
  std::vector<std::string> units = ddd.findDimensionsBoth(pModel);

  CFunctionParameter::Role usage;
  QString qUsage;

  //C_INT32 noOffunctParams = functParam.size();
  Table1->setRowCount((int) params.size());

  for (j = 0; j < params.size(); j++)
    {
      usage = params[j]->getUsage();

      if (usage == CFunctionParameter::VARIABLE &&
          dynamic_cast<CKinFunction *>(mpFunction))
        {
          usage = CFunctionParameter::PARAMETER;
          params[j]->setUsage(usage);
        }

      qUsage = FROM_UTF8(CFunctionParameter::RoleNameDisplay[usage]);

      switch (usage)
        {
          case CFunctionParameter::SUBSTRATE:
            color = subsColor;
            break;

          case CFunctionParameter::PRODUCT:
            color = prodColor;
            break;

          case CFunctionParameter::MODIFIER:
            color = modiColor;
            break;

          case CFunctionParameter::PARAMETER:
            color = paraColor;
            break;

          case CFunctionParameter::VOLUME:
            color = volColor;
            break;

          case CFunctionParameter::TIME:
            color = timeColor;
            break;

          case CFunctionParameter::VARIABLE:
            color = QColor(250, 250, 250);
            break;

          default :
            qUsage = "unknown";
            color = QColor(255, 20, 20);
            break;
        }

      // col. 0 (name)
      QString Name = FROM_UTF8(params[j]->getObjectName());

      if (!params[j]->isUsed())
        Name += " (unused)";

      if (Table1->item((int) j, COL_NAME) == NULL)
        {
          QTableWidgetItem *newItem = new QTableWidgetItem(Name);
          newItem->setFlags(Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
          Table1->setItem((int) j, COL_NAME, newItem);
        }
      else
        Table1->item((int) j, COL_NAME)->setText(Name);

      Table1->item((int) j, COL_NAME)->setBackground(QBrush(color));

      // col. 1 (description)
      QTableWidgetItem *newItem2 = new QTableWidgetItem();
      newItem2->setFlags(Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
      Table1->setItem((int) j, COL_USAGE, newItem2);
      Table1->item((int) j, COL_USAGE)->setBackground(QBrush(color));

      QComboBox *comboItem = new QComboBox(Table1);
      comboItem->addItems(Usages);
      comboItem->setCurrentIndex(comboItem->findText(qUsage));
      comboItem->setDisabled(mReadOnly);

      Table1->setCellWidget((int) j, COL_USAGE, comboItem);

      // connection between comboItem and its parent, Table1
      connect(comboItem, SIGNAL(activated(const QString &)), this, SLOT(slotTableValueChanged(const QString &)));
      comboItem->setObjectName(QString::number(j));  // just need to save the row index

      //col. 2 (units)
      QString strUnit = FROM_UTF8(units[j]);

      if (Table1->item((int) j, COL_UNIT) == NULL)
        {
          QTableWidgetItem *newItem = new QTableWidgetItem(strUnit);
          newItem->setFlags(Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
          Table1->setItem((int) j, COL_UNIT, newItem);
        }
      else
        Table1->item((int) j, COL_UNIT)->setText(strUnit);

      Table1->item((int) j, COL_UNIT)->setBackground(QBrush(color));
    }

  Table1->horizontalHeader()->setStretchLastSection(true);
  Table1->resizeColumnsToContents();
  Table1->resizeRowsToContents();

  /*
  Table1->setFixedSize(Table1->horizontalHeader()->length() + 10,
                       Table1->verticalHeader()->length() + 30);
  */

  return true;
}

bool FunctionWidget1::loadReversibility ( TriLogic  rev )

protected

Definition at line 352 of file FunctionWidget1.cpp.

References TriFalse, TriTrue, and TriUnspecified.

Referenced by loadFromFunction().

{
  switch (rev)
    {
      case TriUnspecified:
        RadioButton3->setEnabled(true);
        RadioButton3->setChecked(true);
        break;

      case TriFalse:
        RadioButton2->setEnabled(true);
        RadioButton2->setChecked(true);
        break;

      case TriTrue:
        RadioButton1->setEnabled(true);
        RadioButton1->setChecked(true);
        break;
    }

  return true;
}

bool FunctionWidget1::loadUsageTable ( )

protected

Function to generate the text representation of the usage restrictions.

Definition at line 255 of file FunctionWidget1.cpp.

References FROM_UTF8, CFunctionParameters::getNumberOfParametersByUsage(), CCopasiObject::getObjectName(), CFunction::getVariables(), CFunctionParameters::isVector(), mpFunction, CFunctionParameter::PRODUCT, and CFunctionParameter::SUBSTRATE.

Referenced by loadFromFunction(), slotFcnDescriptionChanged(), slotReversibilityChanged(), and slotTableValueChanged().

{
  std::vector<std::string> stringlist;
  bool checkSubstrates = false;
  bool checkProducts = false;

  if (RadioButton1->isChecked() == true)
    {
      stringlist.push_back("Only reversible reactions");
      checkSubstrates = true;
      checkProducts = true;
    }
  else if (RadioButton2->isChecked() == true)
    {
      stringlist.push_back("Only irreversible reactions");
      checkSubstrates = true;
    }

  //substrates
  if (checkSubstrates)
    {
      if (mpFunction->getVariables().isVector(CFunctionParameter::SUBSTRATE))
        {
          stringlist.push_back("At least one substrate");
        }
      else if (mpFunction->getObjectName() != "Constant flux (irreversible)" &&
               mpFunction->getObjectName() != "Constant flux (reversible)")
        {
          std::stringstream ss;

          if (mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::SUBSTRATE) == 0)
            {
              ss << "No substrate";
            }
          else
            {
              ss << "Exactly "
                 << mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::SUBSTRATE)
                 << " substrate";

              if (mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::SUBSTRATE) > 1)
                ss << "s"; //plural
            }

          stringlist.push_back(ss.str());
        }
    }

  //products
  if (checkProducts)
    {
      if (mpFunction->getVariables().isVector(CFunctionParameter::PRODUCT))
        {
          stringlist.push_back("At least one product");
        }
      else if (mpFunction->getObjectName() != "Constant flux (reversible)")
        {
          std::stringstream ss;

          if (mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::PRODUCT) == 0 &&
              mpFunction->getObjectName() != "Constant flux (reversible)")
            {
              ss << "No product";
            }
          else
            {
              ss << "Exactly "
                 << mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::PRODUCT)
                 << " product";

              if (mpFunction->getVariables().getNumberOfParametersByUsage(CFunctionParameter::PRODUCT) > 1)
                ss << "s"; //plural
            }

          stringlist.push_back(ss.str());
        }
    }

  if (stringlist.size() == 0)
    stringlist.push_back("None");

  size_t row;

  QString Restrictions("");
  QString Separator("");

  for (row = 0; row < stringlist.size(); ++row)
    {
      Restrictions += Separator + FROM_UTF8(stringlist[row]);
      Separator = ", ";
    }

  mpEditApplicationRestrictions->setText(Restrictions);

  return true;
}

bool FunctionWidget1::saveToFunction ( )

protected

Definition at line 517 of file FunctionWidget1.cpp.

References ListViews::CHANGE, CCopasiDataModel::changed(), CEvaluationTree::compile(), copyFunctionContentsToFunction(), flagChanged, ListViews::FUNCTION, CKeyFactory::get(), CCopasiRootContainer::getKeyFactory(), CFunction::isReversible(), CopasiWidget::mKey, CopasiWidget::mpDataModel, mpFunction, CopasiWidget::protectedNotify(), CFunction::setReversible(), TriFalse, TriTrue, and TriUnspecified.

Referenced by leave().

{
  CFunction* func = dynamic_cast<CFunction*>(CCopasiRootContainer::getKeyFactory()->get(mKey));

  if (!func) return false;

  //radio buttons
  TriLogic tmpl;

  if (RadioButton1->isChecked() == true)
    {
      tmpl = TriTrue;
    }
  else if (RadioButton2->isChecked() == true)
    {
      tmpl = TriFalse;
    }
  else
    {
      tmpl = TriUnspecified;
    }

  if (tmpl != func->isReversible())
    {
      func->setReversible(tmpl);
      flagChanged = true;
    }

  if (flagChanged)
    {
      copyFunctionContentsToFunction(mpFunction, func);

      protectedNotify(ListViews::FUNCTION, ListViews::CHANGE, mKey);

      if (mpDataModel != NULL)
        {
          mpDataModel->changed();
        }

      flagChanged = false;
    }

  func->compile();

  return true;
}

void FunctionWidget1::slotBtnCopy ( )

protectedslot

Definition at line 670 of file FunctionWidget1.cpp.

References CopasiWidget::mKey, and mKeyToCopy.

{
  mKeyToCopy = mKey;
}

void FunctionWidget1::slotBtnDelete ( )

protectedslot

Slot for being activated whenever Delete button is clicked.

Definition at line 676 of file FunctionWidget1.cpp.

References CQMessageBox::confirmDelete(), ListViews::DELETE, FROM_UTF8, ListViews::FUNCTION, CKeyFactory::get(), CEvaluationTree::getDeletedObjects(), CCopasiRootContainer::getFunctionList(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CopasiWidget::mKey, CopasiWidget::protectedNotify(), and CFunctionDB::removeFunction().

{
  CFunctionDB * pFunctionDB = CCopasiRootContainer::getFunctionList();

  if (pFunctionDB == NULL)
    return;

  CEvaluationTree * pFunction = dynamic_cast<CEvaluationTree *>(CCopasiRootContainer::getKeyFactory()->get(mKey));

  if (pFunction == NULL)
    return;

  QMessageBox::StandardButton choice =
    CQMessageBox::confirmDelete(NULL, "function",
                                FROM_UTF8(pFunction->getObjectName()),
                                pFunction->getDeletedObjects());

  /* Check if user chooses to deleted Functions */
  switch (choice)
    {
      case QMessageBox::Ok:                                                    // Yes or Enter
      {
        CCopasiRootContainer::getFunctionList()->removeFunction(mKey);

        protectedNotify(ListViews::FUNCTION, ListViews::DELETE, mKey);
        protectedNotify(ListViews::FUNCTION, ListViews::DELETE, "");//Refresh all as there may be dependencies.
        break;
      }

      default:                                                    // No or Escape
        break;
    }
}

void FunctionWidget1::slotBtnNew ( )

protectedslot

Slot for being activated wehenver New button is clicked.

Definition at line 647 of file FunctionWidget1.cpp.

References CFunctionDB::add(), ListViews::ADD, C_INVALID_INDEX, ListViews::FUNCTION, CCopasiRootContainer::getFunctionList(), CCopasiVectorN< CType >::getIndex(), CFunction::getKey(), CFunctionDB::loadedFunctions(), CopasiWidget::mpListView, CopasiWidget::protectedNotify(), ListViews::switchToOtherWidget(), and TO_UTF8.

{
  std::string name = "function_1";
  int i = 1;
  CFunction* pFunc;
  CCopasiVectorN<CFunction>& FunctionList
  = CCopasiRootContainer::getFunctionList()->loadedFunctions();

  while (FunctionList.getIndex(name) != C_INVALID_INDEX)
    {
      i++;
      name = "function_";
      name += TO_UTF8(QString::number(i));
    }

  CCopasiRootContainer::getFunctionList()->add(pFunc = new CKinFunction(name), true);

  std::string key = pFunc->getKey();
  protectedNotify(ListViews::FUNCTION, ListViews::ADD, key);
  // enter(key);
  mpListView->switchToOtherWidget(C_INVALID_INDEX, key);
}

void FunctionWidget1::slotFcnDescriptionChanged ( bool  valid )

protectedvirtualslot

Slot for changing the function description.

This slot function is called whenever the function description is changed.

Definition at line 571 of file FunctionWidget1.cpp.

References CCopasiMessage::clearDeque(), CEvaluationTree::compile(), CQMessageBox::critical(), flagChanged, CCopasiMessage::getLastMessage(), isValid, loadParameterTable(), loadUsageTable(), MCFunction, mIgnoreFcnDescriptionChange, mpFunction, CCopasiMessage::peekLastMessage(), CFunction::setInfix(), and TO_UTF8.

Referenced by init().

{

  if (mIgnoreFcnDescriptionChange ||
      (mpFunction == NULL))
    return;

  isValid = valid;

  if (isValid)
    {
      try
        {
          if (!mpFunction->setInfix(TO_UTF8(mpExpressionEMSW->getText())) ||
              !mpFunction->compile())
            {
              isValid = true;
            }
        }
      catch (...)
        {
          isValid = false;
        }
    }

  if (isValid)
    {
      flagChanged = true;
      //parameter table
      loadParameterTable();

      // application table
      loadUsageTable();
    }
  else
    {
      if (CCopasiMessage::peekLastMessage().getNumber() == MCFunction + 4)
        {
          CQMessageBox::critical(this, "Function Error",
                                 CCopasiMessage::getLastMessage().getText().c_str(),
                                 QMessageBox::Ok | QMessageBox::Default,
                                 QMessageBox::NoButton);
          CCopasiMessage::clearDeque();
        }
    }
}

void FunctionWidget1::slotReversibilityChanged ( )

protectedvirtualslot

Slot for changing the reversibility of the function.

Definition at line 639 of file FunctionWidget1.cpp.

References loadUsageTable().

{
  loadUsageTable();
}

void FunctionWidget1::slotTableValueChanged ( const QString &  string )

protectedslot

Slot for changing the table value.

Definition at line 619 of file FunctionWidget1.cpp.

References flagChanged, CFunction::getVariables(), loadParameterTable(), loadUsageTable(), and mpFunction.

Referenced by loadParameterTable().

{
  int curRow = sender()->objectName().toInt();

  QComboBox *comboItem = (QComboBox *) sender();

  flagChanged = true;

  CFunctionParameters &functParam = mpFunction->getVariables();

  // surely, we are in COL_USAGE... thus we don't need to check it anymore
  CFunctionParameter::Role usage = (CFunctionParameter::Role)(comboItem->findText(string));
  functParam[curRow]->setUsage(usage);

  //update tables
  loadParameterTable();
  loadUsageTable();
}

bool FunctionWidget1::update ( ListViews::ObjectType  objectType, ListViews::Action  action, const std::string &  key  )

virtual

Function to update the COPASI widgets.

Reimplemented from CopasiWidget.

Definition at line 715 of file FunctionWidget1.cpp.

References ListViews::CHANGE, ListViews::DELETE, ListViews::FUNCTION, CCopasiRootContainer::getKeyFactory(), loadFromFunction(), CopasiWidget::mIgnoreUpdates, CopasiWidget::mKey, and ListViews::MODEL.

{
  if (mIgnoreUpdates) return true;

  switch (objectType)
    {
      case ListViews::MODEL:
        loadFromFunction(dynamic_cast< CFunction * >(CCopasiRootContainer::getKeyFactory()->get(mKey)));
        break;

      case ListViews::FUNCTION:

        if (key == mKey)
          {
            switch (action)
              {
                case ListViews::CHANGE:
                  loadFromFunction(dynamic_cast< CFunction * >(CCopasiRootContainer::getKeyFactory()->get(mKey)));
                  break;

                case ListViews::DELETE:
                  mKey = "";
                  break;

                default:
                  break;
              }
          }

        break;

      default:
        break;
    }

  return true;
}

void FunctionWidget1::updateApplication ( )

protected

Member Data Documentation

bool FunctionWidget1::flagChanged

protected

Definition at line 62 of file FunctionWidget1.h.

Referenced by loadFromFunction(), saveToFunction(), slotFcnDescriptionChanged(), and slotTableValueChanged().

bool FunctionWidget1::isValid

protected

Definition at line 63 of file FunctionWidget1.h.

Referenced by leave(), loadFromFunction(), and slotFcnDescriptionChanged().

bool FunctionWidget1::mIgnoreFcnDescriptionChange

protected

Definition at line 64 of file FunctionWidget1.h.

Referenced by loadFromFunction(), and slotFcnDescriptionChanged().

std::string FunctionWidget1::mKeyToCopy

private

Definition at line 73 of file FunctionWidget1.h.

Referenced by enterProtected(), and slotBtnCopy().

CFunction* FunctionWidget1::mpFunction

protected

Definition at line 66 of file FunctionWidget1.h.

Referenced by functionParametersChanged(), init(), loadFromFunction(), loadParameterTable(), loadUsageTable(), saveToFunction(), slotFcnDescriptionChanged(), slotTableValueChanged(), and ~FunctionWidget1().

bool FunctionWidget1::mReadOnly

private

Definition at line 71 of file FunctionWidget1.h.

Referenced by loadFromFunction(), and loadParameterTable().

---

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

• FunctionWidget1.h
• FunctionWidget1.cpp