#include <CQExpressionWidget.h>

Inheritance diagram for CQExpressionWidget:

Collaboration diagram for CQExpressionWidget:

Public Types
enum	ExpressionType { InitialExpression, TransientExpression, ObjectiveFunctions }

Public Slots
void	slotSelectObject ()

void	slotTextChanged ()

Signals
void	valid (bool valid)

Public Member Functions
	CQExpressionWidget (QWidget parent=0, const char name=0)

std::string	getExpression () const

std::string	getFunction () const

CQValidator< QTextEdit > *	getValidator ()

bool	isValid ()

void	setBoolean (bool isBoolean)

void	setExpression (const std::string &expression)

void	setExpressionType (const ExpressionType &expressionType)

void	setFunction (const std::string &function)

void	writeMathML (std::ostream &out) const

	~CQExpressionWidget ()

Static Public Attributes
static const char	DisplayPattern [] = "\\{(([^\\\\\\}]\|\\\\.)*)\\}"

static const char	InfixPattern [] = "<(CN=([^\\\>]\|\\\\.)*)>"

Protected Member Functions
virtual void	dropEvent (QDropEvent *e)

virtual void	keyPressEvent (QKeyEvent *e)

virtual void	mouseReleaseEvent (QMouseEvent *e)

bool	objectBoundaries (const int &position, int &left, int &right) const

Protected Attributes
QColor	mChangedColor

CQSimpleSelectionTree::ObjectClasses	mObjectClasses

std::map< std::string, const CCopasiObject * >	mParseList

const CCopasiObject *	mpCurrentObject

QColor	mSavedColor

Private Attributes
QTextCursor	mCursor

CQExpressionHighlighter *	mpExpressionHighlighter

CQValidatorExpression *	mpValidatorExpression

CQValidatorFunction *	mpValidatorFunction

Detailed Description

The class for writing/editing a mathematical expression

Definition at line 117 of file CQExpressionWidget.h.

Member Enumeration Documentation

enum CQExpressionWidget::ExpressionType

Enumeration of expression type

Enumerator
InitialExpression
TransientExpression
ObjectiveFunctions

Definition at line 180 of file CQExpressionWidget.h.

   {
     InitialExpression = CQSimpleSelectionTree::InitialTime |
     CQSimpleSelectionTree::Parameters |
     CQSimpleSelectionTree::ObservedConstants,
     TransientExpression = CQSimpleSelectionTree::InitialTime |
     CQSimpleSelectionTree::Parameters |
     CQSimpleSelectionTree::ObservedConstants |
     CQSimpleSelectionTree::Time |
     CQSimpleSelectionTree::Variables |
     CQSimpleSelectionTree::ObservedValues,
     ObjectiveFunctions = CQSimpleSelectionTree::InitialTime |
     CQSimpleSelectionTree::Parameters |
     CQSimpleSelectionTree::ObservedConstants |
     CQSimpleSelectionTree::Time |
     CQSimpleSelectionTree::Variables |
     CQSimpleSelectionTree::ObservedValues |
     CQSimpleSelectionTree::Results
   };

Constructor & Destructor Documentation

CQExpressionWidget::CQExpressionWidget	(	QWidget *	parent = `0`,
		const char *	name = `0`
	)

Definition at line 194 of file CQExpressionWidget.cpp.

References mChangedColor, mpExpressionHighlighter, mSavedColor, and slotTextChanged().

   : QTextEdit(parent),
     mpValidatorExpression(NULL),
     mpValidatorFunction(NULL),
     mObjectClasses(TransientExpression),
     mpCurrentObject(NULL)
 {
   setObjectName(QString::fromUtf8(name));
   setTabChangesFocus(true);
 
   mpExpressionHighlighter = new CQExpressionHighlighter(this);
 
   int h, s, v;
 
   mSavedColor = palette().color(backgroundRole());
   mSavedColor.getHsv(&h, &s, &v);
 
   if (s < 20) s = 20;
 
   mChangedColor.setHsv(240, s, v);
 
   connect(this, SIGNAL(textChanged()),
           this, SLOT(slotTextChanged()));
 }

CQExpressionWidget::~CQExpressionWidget ( )

Definition at line 219 of file CQExpressionWidget.cpp.

220 {}

Member Function Documentation

void CQExpressionWidget::dropEvent ( QDropEvent * e )

protectedvirtual

Function to handle drag leave events.

Definition at line 295 of file CQExpressionWidget.cpp.

References mCursor, and objectBoundaries().

 {
   QString SelectedText = textCursor().selectedText();
 
   QTextEdit::dropEvent(e);
 
   int Left;
   int Right;
 
   if (objectBoundaries(textCursor().position() - SelectedText.length(), Left, Right))
     {
       mCursor = textCursor();
 
       // Remove the inserted text.
       mCursor.setPosition(mCursor.position() - SelectedText.length(), QTextCursor::KeepAnchor);
       mCursor.removeSelectedText();
 
       int CurrentPosition = mCursor.position();
 
       // Determine the insertion point
       objectBoundaries(mCursor.position(), Left, Right);
 
       if (CurrentPosition - Left < Right - CurrentPosition)
         {
           mCursor.setPosition(Left);
         }
       else
         {
           mCursor.setPosition(Right);
         }
 
       mCursor.insertText(SelectedText);
       setTextCursor(mCursor);
     }
 }

std::string CQExpressionWidget::getExpression ( ) const

Retrieve the expression from the widget in string format

Returns: std::string expression

Definition at line 779 of file CQExpressionWidget.cpp.

References DisplayPattern, findObjectByDisplayName(), FROM_UTF8, CCopasiRootContainer::getConfiguration(), CCopasiRootContainer::getDatamodelList(), CCopasiObject::getObjectDataModel(), mParseList, mpCurrentObject, TO_UTF8, and CConfigurationFile::useAdvancedEditing().

Referenced by CQValidatorExpression::validate().

 {
   QString Infix;
   const QString Display(toPlainText());
 
   QRegExp DisplayObjectPattern(CQExpressionWidget::DisplayPattern);
 
   int Index = 0;
   QString::const_iterator it = Display.begin();
   QString::const_iterator end;
 
   while (true)
     {
       Index = DisplayObjectPattern.indexIn(Display, Index);
 
       if (Index < 0)
         {
           end = Display.end();
         }
       else
         {
           end = Display.begin() + Index;
         }
 
       // Copy the non-object part
       for (; it != end; ++it)
         {
           Infix.append(*it);
         }
 
       if (DisplayObjectPattern.matchedLength() < 0)
         break;
 
       Index += DisplayObjectPattern.matchedLength();
       it += DisplayObjectPattern.matchedLength();
 
       std::string DisplayName(TO_UTF8(DisplayObjectPattern.cap(1)));
       std::map< std::string, const CCopasiObject *>::const_iterator itObject = mParseList.find(DisplayName);
 
       if (itObject == mParseList.end() && CCopasiRootContainer::getConfiguration()->useAdvancedEditing())
         {
 
           // the object pattern does not match the species name if
           // the species is in a different compartment, in that case we
           // have to remove the backslash in the displayname.
           std::string::size_type bsPos = DisplayName.find("\\}");
 
           if (bsPos != std::string::npos)
             DisplayName.erase(bsPos, 1);
 
           // here we don't have an object recognized, what we ought to do is to find it in the model
           const CCopasiObject* object = findObjectByDisplayName(
                                           mpCurrentObject != NULL ? mpCurrentObject->getObjectDataModel() : (*CCopasiRootContainer::getDatamodelList())[0],
                                           DisplayName);
 
           if (object != NULL)
             {
               const_cast<CQExpressionWidget*>(this)->mParseList[DisplayName] = object;
               itObject = mParseList.find(DisplayName);
             }
         }
 
       if (itObject != mParseList.end())
         Infix += "<" + FROM_UTF8(itObject->second->getCN()) + ">";
       else
         {
           Infix += "<";
 
           // We need to escape '\'
           std::string CN = TO_UTF8(DisplayObjectPattern.cap(1));
           std::string::const_iterator it = CN.begin();
           std::string::const_iterator end = CN.end();
 
           for (; it < end; ++it)
             {
               if (*it == '\\')
                 {
                   ++it;
                 }
 
               Infix += *it;
             }
 
           Infix += ">";
         }
     }
 
   return TO_UTF8(Infix);
 }

std::string CQExpressionWidget::getFunction ( ) const

Retrieve the function from the widget in string format

Returns: std::string function

Definition at line 550 of file CQExpressionWidget.cpp.

References TO_UTF8.

Referenced by CQValidatorFunction::validate(), and writeMathML().

 {
   return TO_UTF8(toPlainText());
 }

CQValidator< QTextEdit > * CQExpressionWidget::getValidator ( )

Definition at line 222 of file CQExpressionWidget.cpp.

References mpValidatorExpression, and mpValidatorFunction.

 {
   if (mpValidatorExpression != NULL)
     {
       return mpValidatorExpression;
     }
 
   return mpValidatorFunction;
 }

bool CQExpressionWidget::isValid ( )

Check validity of expression

Returns: bool expression

Definition at line 885 of file CQExpressionWidget.cpp.

References mpValidatorExpression, mpValidatorFunction, and CQValidator< Type >::revalidate().

 {
   if (mpValidatorExpression != NULL)
     return mpValidatorExpression->revalidate() == QValidator::Acceptable;
   else if (mpValidatorFunction != NULL)
     return mpValidatorFunction->revalidate() == QValidator::Acceptable;
 
   return true;
 }

void CQExpressionWidget::keyPressEvent ( QKeyEvent * e )

protectedvirtual

Function to handle key press events.

Definition at line 331 of file CQExpressionWidget.cpp.

References CCopasiRootContainer::getConfiguration(), mCursor, objectBoundaries(), and CConfigurationFile::useAdvancedEditing().

 {
   int Left;
   int Right;
   bool isAdvancedEditing = CCopasiRootContainer::getConfiguration()->useAdvancedEditing();
 
   if (e == QKeySequence::SelectNextChar && !isAdvancedEditing)
     {
       mCursor = textCursor();
       mCursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
 
       if (objectBoundaries(mCursor.position(), Left, Right))
         {
           mCursor.setPosition(Right - 1, QTextCursor::KeepAnchor);
           setTextCursor(mCursor);
         }
 
       QTextEdit::keyPressEvent(e);
 
       return;
     }
 
   if (e == QKeySequence::SelectPreviousChar  && !isAdvancedEditing)
     {
       mCursor = textCursor();
       mCursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor);
 
       if (objectBoundaries(mCursor.position(), Left, Right))
         {
           mCursor.setPosition(Left + 1, QTextCursor::KeepAnchor);
           setTextCursor(mCursor);
         }
 
       QTextEdit::keyPressEvent(e);
 
       return;
     }
 
   switch (e->key())
     {
       case Qt::Key_Backspace:
 
         if (isAdvancedEditing) break;
 
         mCursor = textCursor();
 
         if (mCursor.selectedText().isEmpty())
           {
             mCursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor);
 
             if (objectBoundaries(mCursor.position(), Left, Right))
               {
                 mCursor.setPosition(Left + 1, QTextCursor::KeepAnchor);
                 mCursor.deleteChar();
                 setTextCursor(mCursor);
               }
           }
 
         // delete the selected object or just the character
         QTextEdit::keyPressEvent(e);
 
         return;
         break;
 
       case Qt::Key_Delete:
 
         if (isAdvancedEditing) break;
 
         mCursor = textCursor();
 
         if (mCursor.selectedText().isEmpty())
           {
             mCursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
 
             if (objectBoundaries(mCursor.position(), Left, Right))
               {
                 mCursor.setPosition(Right - 1, QTextCursor::KeepAnchor);
                 mCursor.deleteChar();
                 setTextCursor(mCursor);
               }
           }
 
         // delete the selected object or just the character
         QTextEdit::keyPressEvent(e);
 
         return;
         break;
 
       case Qt::Key_Left:
 
         if (isAdvancedEditing) break;
 
         mCursor = textCursor();
 
         // We check whether the new position is in an object.
         mCursor.movePosition(QTextCursor::PreviousCharacter);
 
         if (objectBoundaries(mCursor.position(), Left, Right))
           {
             mCursor.setPosition(Left + 1, QTextCursor::KeepAnchor);
             setTextCursor(mCursor);
           }
 
         QTextEdit::keyPressEvent(e);
 
         return;
         break;
 
       case Qt::Key_Right:
 
         if (isAdvancedEditing) break;
 
         mCursor = textCursor();
 
         // We check whether the new position is in an object.
         mCursor.movePosition(QTextCursor::NextCharacter);
 
         if (objectBoundaries(mCursor.position(), Left, Right))
           {
             mCursor.setPosition(Right - 1, QTextCursor::KeepAnchor);
             setTextCursor(mCursor);
           }
 
         QTextEdit::keyPressEvent(e);
 
         return;
         break;
 
       case Qt::Key_BraceLeft:
       case Qt::Key_BraceRight:
 
         if (isAdvancedEditing) break;
 
         e->ignore();
         return;
         break;
     }
 
   if (!e->text().isEmpty())
     {
       // set format original
       QTextCharFormat f;
       f.setForeground(QColor(0, 0, 0));
 
       setCurrentCharFormat(f);
       QTextEdit::keyPressEvent(e);
 
       return;
     }
 
   QTextEdit::keyPressEvent(e);
 }

void CQExpressionWidget::mouseReleaseEvent ( QMouseEvent * e )

protectedvirtual

Function to handle mouse release events.

Definition at line 267 of file CQExpressionWidget.cpp.

References mCursor, and objectBoundaries().

 {
   QTextEdit::mouseReleaseEvent(e);
 
   mCursor = textCursor();
 
   int Left;
   int Right;
 
   if (objectBoundaries(mCursor.selectionStart(), Left, Right))
     {
       // Move the selection start out of the object.
       mCursor.setPosition(mCursor.selectionEnd());
       mCursor.setPosition(Left, QTextCursor::KeepAnchor);
 
       setTextCursor(mCursor);
     }
 
   if (objectBoundaries(mCursor.selectionEnd(), Left, Right))
     {
       // Move the selection end out of the object.
       mCursor.setPosition(mCursor.selectionStart());
       mCursor.setPosition(Right, QTextCursor::KeepAnchor);
 
       setTextCursor(mCursor);
     }
 }

bool CQExpressionWidget::objectBoundaries	(	const int &	position,
		int &	left,
		int &	right
	)		const

protected

Function to check whether the given cursor position is in an object. If the position is within an object left and right mark the boundaries.

Parameters

const	int & position
int	& left
int	& right

Returns: bool isInObject

Definition at line 504 of file CQExpressionWidget.cpp.

References DisplayPattern.

Referenced by dropEvent(), keyPressEvent(), and mouseReleaseEvent().

 {
   static QRegExp ObjectDisplayPattern(CQExpressionWidget::DisplayPattern);
 
   int Index = ObjectDisplayPattern.indexIn(toPlainText());
 
   while (0 <= Index && Index <= position)
     {
       left = Index;
       Index += ObjectDisplayPattern.matchedLength();
       right = Index;
 
       if (left < position && position < right)
         {
           return true;
         }
 
       Index = ObjectDisplayPattern.indexIn(toPlainText(), Index);
     }
 
   left = -1;
   right = -1;
 
   return false;
 }

void CQExpressionWidget::setBoolean ( bool isBoolean )

Set the boolean

Parameters

bool isBoolean

Definition at line 874 of file CQExpressionWidget.cpp.

References mpValidatorExpression, CQValidator< Type >::revalidate(), and CQValidatorExpression::setBooleanRequired().

 {
   if (mpValidatorExpression == NULL)
     {
       mpValidatorExpression = new CQValidatorExpression(this, "");
       mpValidatorExpression->revalidate();
     }
 
   mpValidatorExpression->setBooleanRequired(isBoolean);
 };

void CQExpressionWidget::setExpression ( const std::string & expression )

Set the expression for the widget

Parameters

const std::string & expression

Definition at line 555 of file CQExpressionWidget.cpp.

References FROM_UTF8, CCopasiRootContainer::getDatamodelList(), CCopasiRootContainer::getFunctionList(), CCopasiObject::getObjectDisplayName(), InfixPattern, mCursor, mParseList, mpValidatorExpression, CCopasiDataModel::ObjectFromName(), CQValidator< Type >::revalidate(), CQValidator< Type >::saved(), and TO_UTF8.

 {
   if (mpValidatorExpression == NULL)
     {
       mpValidatorExpression = new CQValidatorExpression(this, "");
       mpValidatorExpression->revalidate();
     }
 
   // Reset the parse list.
   mParseList.clear();
 
   mCursor = textCursor();
 
   CFunctionDB* pFunDB = CCopasiRootContainer::getFunctionList();
   assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
   CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
   assert(pDataModel != NULL);
   std::vector<CCopasiContainer*> containers;
   containers.push_back(pDataModel);
   containers.push_back(pFunDB);
 
   const QString Infix(FROM_UTF8(expression));
   QString Display;
 
   QRegExp InfixObjectPattern(CQExpressionWidget::InfixPattern);
 
   int Index = 0;
   QString::const_iterator it = Infix.begin();
   QString::const_iterator end;
 
   while (true)
     {
       Index = InfixObjectPattern.indexIn(Infix, Index);
 
       if (Index < 0)
         {
           end = Infix.end();
         }
       else
         {
           end = Infix.begin() + Index;
         }
 
       // Copy the non-object part
       for (; it != end; ++it)
         {
           Display.append(*it);
         }
 
       if (InfixObjectPattern.matchedLength() < 0)
         break;
 
       Index += InfixObjectPattern.matchedLength();
       it += InfixObjectPattern.matchedLength();
 
       CCopasiObjectName InfixName(TO_UTF8(InfixObjectPattern.cap(1)));
       CCopasiObject * pObject = pDataModel->ObjectFromName(containers, InfixName);
 
       if (pObject != NULL)
         {
           std::string DisplayName = pObject->getObjectDisplayName();
 
           // We need to escape '\' and '}'
           std::string::size_type pos = DisplayName.find_first_of("\\}");
 
           while (pos != std::string::npos)
             {
               DisplayName.insert(pos, "\\");
               pos += 2;
               pos = DisplayName.find_first_of("\\}", pos);
             }
 
           mParseList[DisplayName] = pObject;
 
           Display += '{' + FROM_UTF8(DisplayName) + '}';
         }
       else
         {
           std::string DisplayName = InfixName;
 
           // We need to escape '\' and '}'
           std::string::size_type pos = DisplayName.find_first_of("\\}");
 
           while (pos != std::string::npos)
             {
               DisplayName.insert(pos, "\\");
               pos += 2;
               pos = DisplayName.find_first_of("\\}", pos);
             }
 
           Display += '{' + FROM_UTF8(DisplayName) + '}';
         }
     }
 
   setText(Display);
   mpValidatorExpression->saved();
 
   return;
 }

void CQExpressionWidget::setExpressionType ( const ExpressionType & expressionType )

Set the type of the current expression

Parameters

const ExpressionType & expressionType

Definition at line 869 of file CQExpressionWidget.cpp.

References mObjectClasses.

 {
   mObjectClasses = expressionType;
 }

void CQExpressionWidget::setFunction ( const std::string & function )

Set the function for the widget

Parameters

const std::string & function

Definition at line 530 of file CQExpressionWidget.cpp.

References FROM_UTF8, mCursor, mpValidatorFunction, and CQValidator< Type >::revalidate().

 {
   if (mpValidatorFunction == NULL)
     {
       mpValidatorFunction = new CQValidatorFunction(this, "");
       mpValidatorFunction->revalidate();
     }
 
   // clear the text edit
   clear();
 
   mCursor = textCursor();
 
   QTextCharFormat f1;
   f1.setForeground(QColor(0, 0, 0));
 
   setCurrentCharFormat(f1);
   insertPlainText(FROM_UTF8(function));
 }

void CQExpressionWidget::slotSelectObject ( )

slot

Slot for selecting an object

Definition at line 895 of file CQExpressionWidget.cpp.

References CQMessageBox::critical(), CQSimpleSelectionTree::filter(), FROM_UTF8, CCopasiObject::getObjectDisplayName(), CCopasiSelectionDialog::getObjectSingle(), mObjectClasses, CQExpressionHighlighter::mObjectDisplayFormat, mParseList, and mpExpressionHighlighter.

 {
   const CCopasiObject * pObject =
     CCopasiSelectionDialog::getObjectSingle(this, mObjectClasses);
 
   if (pObject)
     {
       // Check whether the object is valid
       if (!CQSimpleSelectionTree::filter(mObjectClasses, pObject))
         {
           CQMessageBox::critical(this, "Invalid Selection",
                                  "The use of the selected object is not allowed in this type of expression.");
           return;
         }
 
       std::string Insert = pObject->getObjectDisplayName();
 
       // We need to escape >
       std::string::size_type pos = Insert.find_first_of("}");
 
       while (pos != std::string::npos)
         {
           Insert.insert(pos, "\\");
           pos += 2;
           pos = Insert.find_first_of("}", pos);
         }
 
       mParseList[Insert] = pObject;
 
       QTextCharFormat f1;
       f1.setForeground(QColor(0, 0, 0));
 
       QTextCharFormat f = mpExpressionHighlighter->mObjectDisplayFormat;
       //QColor color2 = f.foreground().color();
 
       setCurrentCharFormat(f);
       insertPlainText(FROM_UTF8("{" + Insert + "}"));
       setCurrentCharFormat(f1);
     }
 }

void CQExpressionWidget::slotTextChanged ( )

slot

Slot for being activated whenever the text on Expression Widget is changed

This slot checks any characters that are newly typed on Expression Widget.

Definition at line 487 of file CQExpressionWidget.cpp.

References mpValidatorExpression, mpValidatorFunction, valid(), and CQValidator< Type >::validate().

Referenced by CQExpressionWidget().

 {
   CQValidator< QTextEdit > * pValidator = NULL;
 
   if (mpValidatorExpression != NULL)
     pValidator = mpValidatorExpression;
   else if (mpValidatorFunction != NULL)
     pValidator = mpValidatorFunction;
   else
     return;
 
   int pos = 0;
   QString Input = toPlainText();
 
   emit valid(pValidator->validate(Input, pos) == QValidator::Acceptable);
 }

void CQExpressionWidget::valid ( bool valid )

signal

Signal for being sent whenever the expression is valid

Referenced by slotTextChanged().

void CQExpressionWidget::writeMathML ( std::ostream & out ) const

Write display mathml of the expression into the ostream "out"

Definition at line 232 of file CQExpressionWidget.cpp.

References CFunction::createListOfParametersForMathML(), CQValidatorExpression::getExpression(), CQValidatorFunction::getFunction(), getFunction(), CMassAction::Infix, mpValidatorExpression, mpValidatorFunction, TriFalse, TriTrue, CMassAction::writeMathML(), CExpression::writeMathML(), and CFunction::writeMathML().

 {
   if (mpValidatorExpression != NULL)
     mpValidatorExpression->getExpression()->writeMathML(out, false, 0);
   else if (mpValidatorFunction != NULL)
     {
       std::string Infix = getFunction();
 
       if (Infix == CMassAction::Infix[0])
         {
           CMassAction Function(TriTrue, NULL);
           std::vector<std::vector<std::string> > params;
 
           Function.createListOfParametersForMathML(params);
           out << Function.writeMathML(params, true, false);
         }
       else if (Infix == CMassAction::Infix[1])
         {
           CMassAction Function(TriFalse, NULL);
           std::vector<std::vector<std::string> > params;
 
           Function.createListOfParametersForMathML(params);
           out << Function.writeMathML(params, true, false);
         }
       else
         {
           std::vector<std::vector<std::string> > params;
           mpValidatorFunction->getFunction()->createListOfParametersForMathML(params);
           out << mpValidatorFunction->getFunction()->writeMathML(params, true, false);
         }
     }
 
   return;
 }