#include <CQReactionDM.h>

Inheritance diagram for CQReactionDM:

Collaboration diagram for CQReactionDM:

Public Member Functions
virtual int	columnCount (const QModelIndex &parent=QModelIndex()) const

	CQReactionDM (QObject *parent=0)

QVariant	data (const QModelIndex &index, int role) const

Qt::ItemFlags	flags (const QModelIndex &index) const

QVariant	headerData (int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const

bool	removeRows (QModelIndexList rows, const QModelIndex &index=QModelIndex())

virtual int	rowCount (const QModelIndex &parent=QModelIndex()) const

bool	setData (const QModelIndex &index, const QVariant &value, int role=Qt::EditRole)

Public Member Functions inherited from CQBaseDataModel
virtual bool	clear ()

	CQBaseDataModel (QObject *parent=0)

QString	createNewName (const QString name, const int nameCol)

bool	insertRow ()

virtual bool	isDefaultRow (const QModelIndex &i) const

bool	removeRow (int position)

Protected Member Functions
bool	insertRows (int position, int rows, const QModelIndex &index=QModelIndex())

bool	removeRows (int position, int rows, const QModelIndex &index=QModelIndex())

Private Member Functions
void	setEquation (const CReaction *pRea, const QModelIndex &index, const QVariant &value)

Private Attributes
QString	mNewEquation

Additional Inherited Members
Signals inherited from CQBaseDataModel
void	notifyGUI (ListViews::ObjectType objectType, ListViews::Action action, const std::string &key="")

Detailed Description

Definition at line 32 of file CQReactionDM.h.

Constructor & Destructor Documentation

CQReactionDM::CQReactionDM ( QObject * parent = 0 )

Definition at line 24 of file CQReactionDM.cpp.

                                          :
   CQBaseDataModel(parent),
   mNewEquation()
 {}

Member Function Documentation

int CQReactionDM::columnCount ( const QModelIndex & parent = QModelIndex() ) const

virtual

Definition at line 33 of file CQReactionDM.cpp.

References TOTAL_COLS_REACTIONS.

Referenced by CQReactionsWidget::keyPressEvent().

 {
   return TOTAL_COLS_REACTIONS;
 }

QVariant CQReactionDM::data	(	const QModelIndex &	index,
		int	role
	)		const

virtual

Implements CQBaseDataModel.

Definition at line 49 of file CQReactionDM.cpp.

References COL_EQUATION, COL_FLUX, COL_NAME_REACTIONS, COL_PARTICLE_FLUX, COL_RATE_LAW, COL_ROW_NUMBER, flags(), FROM_UTF8, CChemEqInterface::getChemEqString(), CCopasiRootContainer::getDatamodelList(), CReaction::getFlux(), CReaction::getFunction(), CCopasiObject::getObjectName(), CReaction::getParticleFlux(), CQBaseDataModel::isDefaultRow(), mNewEquation, and rowCount().

Referenced by setData(), and setEquation().

 {
   if (!index.isValid())
     return QVariant();
 
   if (index.row() >= rowCount())
     return QVariant();
 
   if (index.column() > 0 && role == Qt::ForegroundRole && !(flags(index) & Qt::ItemIsEditable))
     return QColor(Qt::darkGray);
 
   if (role == Qt::DisplayRole || role == Qt::EditRole)
     {
       if (isDefaultRow(index))
         {
           switch (index.column())
             {
               case COL_ROW_NUMBER:
                 return QVariant(QString(""));
 
               case COL_NAME_REACTIONS:
                 return QVariant(QString("New Reaction"));
 
               default:
                 return QVariant(QString(""));
             }
         }
       else
         {
           CReaction *pRea = (*CCopasiRootContainer::getDatamodelList())[0]->getModel()->getReactions()[index.row()];
 
           switch (index.column())
             {
               case COL_ROW_NUMBER:
                 return QVariant(index.row() + 1);
 
               case COL_NAME_REACTIONS:
                 return QVariant(QString(FROM_UTF8(pRea->getObjectName())));
 
               case COL_EQUATION:
 
                 if (mNewEquation.isEmpty())
                   {
                     return QVariant(QString(FROM_UTF8(CChemEqInterface::getChemEqString((*CCopasiRootContainer::getDatamodelList())[0]->getModel(), *pRea, false))));
                   }
                 else
                   {
                     return QVariant(mNewEquation);
                   }
 
               case COL_RATE_LAW:
 
                 if (pRea->getFunction())
                   return QVariant(QString(FROM_UTF8(pRea->getFunction()->getObjectName())));
                 else
                   return QVariant();
 
               case COL_FLUX:
                 return QVariant(pRea->getFlux());
 
               case COL_PARTICLE_FLUX:
                 return QVariant(pRea->getParticleFlux());
             }
         }
     }
 
   return QVariant();
 }

Qt::ItemFlags CQReactionDM::flags ( const QModelIndex & index ) const

virtual

Reimplemented from CQBaseDataModel.

Definition at line 38 of file CQReactionDM.cpp.

References COL_EQUATION, and COL_NAME_REACTIONS.

Referenced by data().

 {
   if (!index.isValid())
     return Qt::ItemIsEnabled;
 
   if (index.column() == COL_NAME_REACTIONS || index.column() == COL_EQUATION)
     return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
   else
     return QAbstractItemModel::flags(index);
 }

QVariant CQReactionDM::headerData	(	int	section,
		Qt::Orientation	orientation,
		int	role = `Qt::DisplayRole`
	)		const

virtual

Implements CQBaseDataModel.

Definition at line 118 of file CQReactionDM.cpp.

References COL_EQUATION, COL_FLUX, COL_NAME_REACTIONS, COL_PARTICLE_FLUX, COL_RATE_LAW, COL_ROW_NUMBER, FROM_UTF8, CCopasiRootContainer::getDatamodelList(), CModel::getFrequencyUnitsDisplayString(), and CModel::getQuantityRateUnitsDisplayString().

 {
   if (role != Qt::DisplayRole)
     return QVariant();
 
   if (orientation == Qt::Horizontal)
     {
       switch (section)
         {
           case COL_ROW_NUMBER:
             return QVariant(QString("#"));
 
           case COL_NAME_REACTIONS:
             return QVariant(QString("Name"));
 
           case COL_EQUATION:
             return QVariant(QString("Reaction"));
 
           case COL_RATE_LAW:
             return QVariant(QString("Rate Law"));
 
           case COL_FLUX:
           {
             const CModel * pModel = (*CCopasiRootContainer::getDatamodelList())[0]->getModel();
 
             if (pModel == NULL) return QVariant();
 
             QString RateUnits;
 
             if (pModel)
               RateUnits = FROM_UTF8(pModel->getQuantityRateUnitsDisplayString());
 
             if (!RateUnits.isEmpty())
               RateUnits = "\n(" + RateUnits + ")";
 
             return QVariant("Flux" + RateUnits);
           }
 
           case COL_PARTICLE_FLUX:
           {
             const CModel * pModel = (*CCopasiRootContainer::getDatamodelList())[0]->getModel();
 
             if (pModel == NULL) return QVariant();
 
             QString FrequencyUnits;
 
             if (pModel)
               FrequencyUnits = FROM_UTF8(pModel->getFrequencyUnitsDisplayString());
 
             if (!FrequencyUnits.isEmpty())
               FrequencyUnits = "\n(" + FrequencyUnits + ")";
 
             return QVariant("Flux" + FrequencyUnits);
           }
 
           default:
             return QVariant();
         }
     }
   else
     return QString("%1").arg(section + 1);
 }

bool CQReactionDM::insertRows	(	int	position,
		int	rows,
		const QModelIndex &	index = `QModelIndex()`
	)

protectedvirtual

Implements CQBaseDataModel.

Definition at line 327 of file CQReactionDM.cpp.

References ListViews::ADD, COL_NAME_REACTIONS, CQBaseDataModel::createNewName(), CCopasiRootContainer::getDatamodelList(), CReaction::getKey(), CQBaseDataModel::notifyGUI(), ListViews::REACTION, and TO_UTF8.

 {
   beginInsertRows(QModelIndex(), position, position + rows - 1);
 
   for (int row = 0; row < rows; ++row)
     {
       CReaction *pRea = (*CCopasiRootContainer::getDatamodelList())[0]->getModel()->createReaction(TO_UTF8(createNewName("reaction", COL_NAME_REACTIONS)));
       emit notifyGUI(ListViews::REACTION, ListViews::ADD, pRea->getKey());
     }
 
   endInsertRows();
 
   return true;
 }

bool CQReactionDM::removeRows	(	QModelIndexList	rows,
		const QModelIndex &	index = `QModelIndex()`
	)

Definition at line 376 of file CQReactionDM.cpp.

References C_INVALID_INDEX, CQMessageBox::confirmDelete(), FROM_UTF8, CCopasiRootContainer::getDatamodelList(), CReaction::getDeletedObjects(), CCopasiDataModel::getModel(), CCopasiObject::getObjectName(), CModel::getReactions(), CQBaseDataModel::isDefaultRow(), and CQBaseDataModel::removeRow().

Referenced by CQReactionsWidget::deleteSelectedReactions().

 {
   if (rows.isEmpty())
     return false;
 
   assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
   CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
   assert(pDataModel != NULL);
   CModel * pModel = pDataModel->getModel();
 
   if (pModel == NULL)
     return false;
 
 //Build the list of pointers to items to be deleted
 //before actually deleting any item.
   QList <CReaction *> pReactions;
   QModelIndexList::const_iterator i;
 
   for (i = rows.begin(); i != rows.end(); ++i)
     {
       if (!isDefaultRow(*i) && pModel->getReactions()[(*i).row()])
         pReactions.append(pModel->getReactions()[(*i).row()]);
     }
 
   QList <CReaction *>::const_iterator j;
 
   for (j = pReactions.begin(); j != pReactions.end(); ++j)
     {
       CReaction * pReaction = *j;
 
       size_t delRow =
         pModel->getReactions().CCopasiVector< CReaction >::getIndex(pReaction);
 
       if (delRow != C_INVALID_INDEX)
         {
           QMessageBox::StandardButton choice =
             CQMessageBox::confirmDelete(NULL, "reaction",
                                         FROM_UTF8(pReaction->getObjectName()),
                                         pReaction->getDeletedObjects());
 
           if (choice == QMessageBox::Ok)
             removeRow((int) delRow);
         }
     }
 
   return true;
 }

bool CQReactionDM::removeRows	(	int	position,
		int	rows,
		const QModelIndex &	index = `QModelIndex()`
	)

protectedvirtual

Implements CQBaseDataModel.

Definition at line 342 of file CQReactionDM.cpp.

References CCopasiVector< T >::begin(), ListViews::DELETE, CCopasiRootContainer::getDatamodelList(), CModel::getReactions(), CQBaseDataModel::notifyGUI(), ListViews::REACTION, and CModel::removeReaction().

 {
   if (rows <= 0)
     return true;
 
   beginRemoveRows(QModelIndex(), position, position + rows - 1);
 
   CModel * pModel = (*CCopasiRootContainer::getDatamodelList())[0]->getModel();
 
   std::vector< std::string > DeletedKeys;
   DeletedKeys.resize(rows);
 
   std::vector< std::string >::iterator itDeletedKey;
   std::vector< std::string >::iterator endDeletedKey = DeletedKeys.end();
 
   CCopasiVector< CReaction >::const_iterator itRow = pModel->getReactions().begin() + position;
 
   for (itDeletedKey = DeletedKeys.begin(); itDeletedKey != endDeletedKey; ++itDeletedKey, ++itRow)
     {
       *itDeletedKey = (*itRow)->getKey();
     }
 
   for (itDeletedKey = DeletedKeys.begin(); itDeletedKey != endDeletedKey; ++itDeletedKey)
     {
       pModel->removeReaction(*itDeletedKey);
       emit notifyGUI(ListViews::REACTION, ListViews::DELETE, *itDeletedKey);
       emit notifyGUI(ListViews::REACTION, ListViews::DELETE, "");//Refresh all as there may be dependencies.
     }
 
   endRemoveRows();
 
   return true;
 }

int CQReactionDM::rowCount ( const QModelIndex & parent = QModelIndex() ) const

virtual

Definition at line 29 of file CQReactionDM.cpp.

References CCopasiRootContainer::getDatamodelList().

Referenced by data(), and CQReactionsWidget::deleteSelectedReactions().

 {
   return (int)(*CCopasiRootContainer::getDatamodelList())[0]->getModel()->getReactions().size() + 1;
 }

bool CQReactionDM::setData	(	const QModelIndex &	index,
		const QVariant &	value,
		int	role = `Qt::EditRole`
	)

virtual

Implements CQBaseDataModel.

Definition at line 182 of file CQReactionDM.cpp.

References ListViews::CHANGE, COL_EQUATION, COL_NAME_REACTIONS, CQBaseDataModel::createNewName(), data(), CCopasiRootContainer::getDatamodelList(), CReaction::getKey(), CQBaseDataModel::insertRow(), CQBaseDataModel::isDefaultRow(), CQBaseDataModel::notifyGUI(), ListViews::REACTION, setEquation(), CCopasiObject::setObjectName(), and TO_UTF8.

 {
   if (index.isValid() && role == Qt::EditRole)
     {
       bool defaultRow = isDefaultRow(index);
 
       if (defaultRow)
         {
           if (index.data() != value)
             insertRow();
           else
             return false;
         }
 
       // this loads the reaction into a CReactionInterface object.
       // the gui works on this object and later writes back the changes to ri;
       assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
       CReactionInterface ri((*CCopasiRootContainer::getDatamodelList())[0]->getModel());
       CReaction *pRea = (*CCopasiRootContainer::getDatamodelList())[0]->getModel()->getReactions()[index.row()];
 
       if (index.column() == COL_NAME_REACTIONS)
         pRea->setObjectName(TO_UTF8(value.toString()));
       else if (index.column() == COL_EQUATION)
         setEquation(pRea, index, value);
 
       if (defaultRow && this->index(index.row(), COL_NAME_REACTIONS).data().toString() == "reaction")
         pRea->setObjectName(TO_UTF8(createNewName("reaction", COL_NAME_REACTIONS)));
 
       emit dataChanged(index, index);
       emit notifyGUI(ListViews::REACTION, ListViews::CHANGE, pRea->getKey());
     }
 
   return true;
 }

void CQReactionDM::setEquation	(	const CReaction *	pRea,
		const QModelIndex &	index,
		const QVariant &	value
	)

private

Definition at line 218 of file CQReactionDM.cpp.

References ListViews::ADD, ListViews::CHANGE, COL_NAME_REACTIONS, CQMessageBox::confirmDelete(), CReactionInterface::createMetabolites(), CReactionInterface::createOtherObjects(), data(), ListViews::DELETE, FROM_UTF8, CKeyFactory::get(), CReactionInterface::getChemEqString(), CCopasiRootContainer::getDatamodelList(), CReactionInterface::getDeletedParameters(), CReaction::getKey(), CCopasiRootContainer::getKeyFactory(), CCopasiDataModel::getModel(), CReactionInterface::initFromReaction(), CChemEqInterface::isValidEq(), ListViews::METABOLITE, mNewEquation, ListViews::MODEL, CQBaseDataModel::notifyGUI(), ListViews::REACTION, CModel::removeLocalReactionParameter(), CReactionInterface::setChemEqString(), CReactionInterface::setFunctionWithEmptyMapping(), TO_UTF8, and CReactionInterface::writeBackToReaction().

Referenced by setData().

 {
   std::string objKey = pRea->getKey();
   mNewEquation = value.toString();
 
   assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
   CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
   assert(pDataModel != NULL);
   CModel * pModel = pDataModel->getModel();
 
   if (pModel == NULL) return;
 
   // this loads the reaction into a CReactionInterface object.
   // the gui works on this object and later writes back the changes to ri;
   assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
   CReactionInterface ri((*CCopasiRootContainer::getDatamodelList())[0]->getModel());
   ri.initFromReaction(objKey);
 
   if (TO_UTF8(mNewEquation) != ri.getChemEqString())
     {
       //first check if the string is a valid equation
       if (!CChemEqInterface::isValidEq(TO_UTF8(mNewEquation)))
         {
           mNewEquation = "";
           return;
         }
       else
         {
           //tell the reaction interface
           ri.setChemEqString(TO_UTF8(mNewEquation), "");
         }
     }
 
   // Before we save any changes we must check whether any local reaction parameters,
   // which are used in any mathematical expression in the model are removed.
   // If that is the case the user must have option to cancel the changes or remove the
   // affected expressions.
   std::set< const CCopasiObject * > DeletedParameters = ri.getDeletedParameters();
 
   if (DeletedParameters.size() != 0)
     {
       QString ObjectType = "parameter(s) of reaction " + this->index(index.row(), COL_NAME_REACTIONS).data().toString();
       QString Objects;
 
       std::set< const CCopasiObject * >::const_iterator itParameter, endParameter = DeletedParameters.end();
       std::set< const CCopasiObject * > DeletedObjects;
 
       for (itParameter = DeletedParameters.begin(); itParameter != endParameter; ++itParameter) //all parameters
         {
           Objects.append(FROM_UTF8((*itParameter)->getObjectName()) + ", ");
           DeletedObjects.insert(static_cast< const CCopasiObject * >((*itParameter)->getObject(CCopasiObjectName("Reference=Value"))));
         }
 
       Objects.remove(Objects.length() - 2, 2);
 
       QMessageBox::StandardButton choice =
         CQMessageBox::confirmDelete(NULL, ObjectType,
                                     Objects, DeletedObjects);
 
       switch (choice)
         {
           case QMessageBox::Ok:
 
             for (itParameter = DeletedParameters.begin(); itParameter != endParameter; ++itParameter) //all parameters
               pModel->removeLocalReactionParameter((*itParameter)->getKey());
 
             break;
 
           default:
             mNewEquation = "";
             return;
             break;
         }
     }
 
   // We need to check whether the current reaction still exists, since it is possible that
   // removing a local reaction parameter triggers its deletion.
   CReaction * reac = dynamic_cast< CReaction * >(CCopasiRootContainer::getKeyFactory()->get(objKey));
 
   if (reac == NULL)
     {
       ri.setFunctionWithEmptyMapping("");
       emit notifyGUI(ListViews::REACTION, ListViews::DELETE, objKey);
       emit notifyGUI(ListViews::REACTION, ListViews::DELETE, ""); //Refresh all as there may be dependencies.
       mNewEquation = "";
       return;
     }
 
   //first check if new metabolites need to be created
   bool createdMetabs = ri.createMetabolites();
   bool createdObjects = ri.createOtherObjects();
   //this writes all changes to the reaction
   ri.writeBackToReaction(NULL);
 
   //(*CCopasiRootContainer::getDatamodelList())[0]->getModel()->compile();
   //this tells the gui what it needs to know.
   if (createdObjects ||
       DeletedParameters.size() != 0)
     {
       emit notifyGUI(ListViews::MODEL, ListViews::CHANGE, "");
     }
   else if (createdMetabs)
     {
       emit notifyGUI(ListViews::METABOLITE, ListViews::ADD, "");
     }
 
   mNewEquation = "";
 }

Member Data Documentation

QString CQReactionDM::mNewEquation

private

Definition at line 55 of file CQReactionDM.h.

Referenced by data(), and setEquation().

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation