#include <CListOfLayouts.h>

Inheritance diagram for CListOfLayouts:

Collaboration diagram for CListOfLayouts:

Public Member Functions
void	addGlobalRenderInformation (CLGlobalRenderInformation *pRenderInfo)

void	addLayout (CLayout *layout, const std::map< std::string, std::string > &m)

	CListOfLayouts (const std::string &name="ListOfLayouts", const CCopasiContainer *pParent=NULL)

void	exportToSBML (ListOf lol, std::map< const CCopasiObject , SBase * > &copasimodelmap, const std::map< std::string, const SBase * > &idMap, unsigned int level, unsigned int version) const

const std::string &	getKey ()

const CCopasiVector < CLGlobalRenderInformation > &	getListOfGlobalRenderInformationObjects () const

CCopasiVector < CLGlobalRenderInformation > &	getListOfGlobalRenderInformationObjects ()

CLGlobalRenderInformation *	getRenderInformation (size_t index)

const CLGlobalRenderInformation *	getRenderInformation (size_t index) const

	~CListOfLayouts ()

Public Member Functions inherited from CCopasiVector< CLayout >
virtual bool	add (const CType &src)

virtual bool	add (CType *src, bool adopt=false)

iterator	begin ()

const_iterator	begin () const

	CCopasiVector (const std::string &name="NoName", const CCopasiContainer *pParent=NULL, const unsigned C_INT32 &flag=CCopasiObject::Vector)

	CCopasiVector (const CCopasiVector< CType > &src, const CCopasiContainer *pParent=NULL)

virtual void	cleanup ()

virtual void	clear ()

void	deepCopy (const CCopasiVector< CType > &source)

iterator	end ()

const_iterator	end () const

virtual size_t	getIndex (const CCopasiObject *pObject) const

virtual const CObjectInterface *	getObject (const CCopasiObjectName &name) const

CCopasiVector< CType > &	operator= (const CCopasiVector< CType > &rhs)

CCopasiVector< CType > &	operator= (const std::vector< CType * > &rhs)

const value_type &	operator[] (const size_t &index) const

value_type &	operator[] (const size_t &index)

virtual void	remove (const size_t &index)

virtual bool	remove (CCopasiObject *pObject)

virtual void	resize (const size_t &newSize)

virtual size_t	size () const

virtual void	swap (const size_t &indexFrom, const size_t &indexTo)

virtual	~CCopasiVector ()

Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)

	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)

	CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)

virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual	~CCopasiContainer ()

Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)

	CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)

void	clearDirectDependencies ()

void	clearRefresh ()

bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const

void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const

virtual CCopasiObjectName	getCN () const

virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const

virtual const std::string &	getKey () const

CCopasiContainer *	getObjectAncestor (const std::string &type) const

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) const

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

virtual void *	getValuePointer () const

bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

virtual void	print (std::ostream *ostream) const

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

template<class CType >
void	setRefresh (CType pType, void(CType::method)(void))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_FLOAT64 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_INT32 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const bool &))

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Private Attributes
std::string	mKey

CCopasiVector < CLGlobalRenderInformation >	mvGlobalRenderInformationObjects

Additional Inherited Members
Public Types inherited from CCopasiVector< CLayout >
typedef std::vector< CType * > ::const_iterator	const_iterator

typedef std::vector< CType * > ::iterator	iterator

typedef std::vector< CType * > ::value_type	value_type

Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap

Public Types inherited from CCopasiObject
typedef std::set< const CCopasiObject * >	DataObjectSet

typedef std::vector< Refresh * >	DataUpdateSequence

Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet

typedef std::vector < CObjectInterface * >	UpdateSequence

Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())

static void	setRenameHandler (CRenameHandler *rh)

Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList

Protected Types inherited from CCopasiObject
enum	Flag { Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8, Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80, ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800, Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000, Root = 0x10000, Gui = 0x20000 }

Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

this class stores a list of layouts. It should also keep the maps that translate from sbml IDs to COPASI keys

Definition at line 29 of file CListOfLayouts.h.

Constructor & Destructor Documentation

CListOfLayouts::CListOfLayouts	(	const std::string &	name = `"ListOfLayouts"`,
		const CCopasiContainer *	pParent = `NULL`
	)

Definition at line 57 of file CListOfLayouts.cpp.

                                                                 :
   CCopasiVector<CLayout>(name, pParent),
   mKey(CCopasiRootContainer::getKeyFactory()->add("Layout", this))
   , mvGlobalRenderInformationObjects("ListOfGlobalRenderInformationObjects", this)
 {}

CListOfLayouts::~CListOfLayouts ( )

Definition at line 64 of file CListOfLayouts.cpp.

References CCopasiRootContainer::getKeyFactory(), mKey, and CKeyFactory::remove().

 {
   CCopasiRootContainer::getKeyFactory()->remove(mKey);
 }

Member Function Documentation

void CListOfLayouts::addGlobalRenderInformation ( CLGlobalRenderInformation * pRenderInfo )

add local render information to layout. The layout takes ownership of the object.

Definition at line 213 of file CListOfLayouts.cpp.

References CCopasiVector< T >::add(), and mvGlobalRenderInformationObjects.

Referenced by test000097::addGlobalRenderInformation(), SBMLDocumentLoader::readListOfLayouts(), and CCopasiXMLParser::GlobalRenderInformationElement::start().

 {
   if (pRenderInfo)
     {
       this->mvGlobalRenderInformationObjects.add(pRenderInfo, true); //true means vector takes ownership
     }
 }

void CListOfLayouts::addLayout	(	CLayout *	layout,
		const std::map< std::string, std::string > &	m
	)

Add a layout to the list. At the moment the map is just ignored. Later it should be stored somewhere

Definition at line 74 of file CListOfLayouts.cpp.

References CCopasiVector< CLayout >::add().

Referenced by test000097::createModel(), DataModelGUI::importCellDesigner(), SBMLDocumentLoader::readListOfLayouts(), and CQLayoutsWidget::slotBtnNewClicked().

 {
   if (layout)
     add(layout, true);
 
   //TODO: store map
 }

void CListOfLayouts::exportToSBML	(	ListOf *	lol,
		std::map< const CCopasiObject , SBase > &	copasimodelmap,
		const std::map< std::string, const SBase * > &	idMap,
		unsigned int	level,
		unsigned int	version
	)		const

This method writes the information of the copasi layout object into the corresponding sbml object. copasimodelmap maps the copasi model objects to libsbml objects. At the moment we don´t assume layout objects are in the copasimodelmap. idSet should contain all sbml IDs that are used in the currently exported model (including the layouts, but not the objects inside the layout).

Definition at line 82 of file CListOfLayouts.cpp.

References CLayout::exportToSBML(), getKey(), LAYOUT_CREATE_NS, mvGlobalRenderInformationObjects, pdelete, CCopasiVector< T >::size(), and CCopasiVector< CLayout >::size().

Referenced by CSBMLExporter::exportModelToString().

 {
   if (!lol) return;
 
   size_t i, imax;
   // the global render information has to be handled first, because we might need
   // some of the maps for the export of the local render information in the layout
   ListOfLayouts* pLoL = dynamic_cast<ListOfLayouts*>(lol);
   assert(pLoL != NULL);
   imax = this->mvGlobalRenderInformationObjects.size();
   GlobalRenderInformation* pGRI = NULL;
   std::map<std::string, std::string> keyToIdMap;
 
   /*
   std::map<std::string,std::string> colorKeyToIdMap;
   std::map<std::string,std::string> gradientKeyToIdMap;
   std::map<std::string,std::string> lineEndingKeyToIdMap;
   std::map<std::string,std::map<std::string,std::string> > colorKeyToIdMapMap;
   std::map<std::string,std::map<std::string,std::string> > gradientKeyToIdMapMap;
   std::map<std::string,std::map<std::string,std::string> > lineEndingKeyToIdMapMap;
   */
 
   RenderListOfLayoutsPlugin* rlolPlugin = (RenderListOfLayoutsPlugin*) lol->getPlugin("render");
 
   if (rlolPlugin == NULL)
     {
       // we do not yet have a render layout plugin so let us enable it
       const std::string uri = (lol->getLevel() < 3 ? RenderExtension::getXmlnsL2() : RenderExtension::getXmlnsL3V1V1());
       lol->enablePackage(uri, "render", true);
       rlolPlugin = (RenderListOfLayoutsPlugin*) lol->getPlugin("render");
 
       if (lol->getLevel() > 2)
         lol->getSBMLDocument()->setPackageRequired("render", false);
     }
 
   assert(rlolPlugin != NULL);
 
   for (i = 0; i < imax; ++i)
     {
       //colorKeyToIdMap.clear();
       //gradientKeyToIdMap.clear();
       //lineEndingKeyToIdMap.clear();
       //pGRI=this->mvGlobalRenderInformationObjects[i]->toSBML(colorKeyToIdMap,gradientKeyToIdMap,lineEndingKeyToIdMap);
       pGRI = rlolPlugin->createGlobalRenderInformation();
       this->mvGlobalRenderInformationObjects[i]->toSBML(pGRI, pLoL->getLevel(), pLoL->getVersion());
       // add the id and key to the map
       assert(pGRI != NULL);
       keyToIdMap.insert(std::pair<std::string, std::string>(this->mvGlobalRenderInformationObjects[i]->getKey(), pGRI->getId()));
       //colorKeyToIdMapMap.insert(std::pair<std::string,std::map<std::string,std::string> >(pGRI->getId(),colorKeyToIdMap));
       //gradientKeyToIdMapMap.insert(std::pair<std::string,std::map<std::string,std::string> >(pGRI->getId(),gradientKeyToIdMap));
       //lineEndingKeyToIdMapMap.insert(std::pair<std::string,std::map<std::string,std::string> >(pGRI->getId(),lineEndingKeyToIdMap));
     }
 
   // fix the references
   // we need to pass the ListOfGlobalRenderInformation objects as the first argument
   SBMLDocumentLoader::convertRenderInformationReferencesKeys<GlobalRenderInformation>(*(rlolPlugin->getListOfGlobalRenderInformation()), keyToIdMap);
   // fix the color ids, gradient ids and line ending ids.
 
   // we will generate sbml ids that are unique within the sbml file (although
   // this may not be strictly necessary for the layouts). Therefore we will keep only
   // one set of IDs:
   std::map<std::string, const SBase*> sbmlIDs = idMap;
 
   //this will contain the SBML objects that were touched by this method.
   std::set<SBase*> writtenToSBML;
 
   //some of the following code is currently useless: Layouts are never part of
   //the copasimodelmap.
 
   //write all COPASI object to corresponding libsbml objects
   imax = this->size();
 
   for (i = 0; i < imax; ++i)
     {
       CLayout * tmp = (*this)[i];
 
       //check if the layout exists in the libsbml data
       std::map<const CCopasiObject*, SBase*>::const_iterator it;
       it = copasimodelmap.find(tmp);
 
       Layout * pLayout;
 
       if (it == copasimodelmap.end()) //not found
         {
           //create new object and add to libsbml data structures
           // the layout needs to be created with the correct level and version
           // otherwise the render infromation is not correctly exported
           // because newer version is libsbml set the level to 3 per default
           //pLayout = new Layout(level, version);
 
           // the issue with the above is that the render package is not automatically
           // instantiated (we really ought to simply call ->createLayout on the plugin object)
           // until then we simply take all the namespaces from the parent element with us
           LAYOUT_CREATE_NS(layoutns, lol->getSBMLNamespaces());
           pLayout = new Layout(layoutns);
 
           lol->appendAndOwn(pLayout);
 
           //add object to map
           //copasimodelmap[tmp] = pLayout; should not really be done in export
         }
       else
         {
           pLayout = dynamic_cast<Layout*>(it->second);
         }
 
       //tmp->exportToSBML(pLayout, copasimodelmap, sbmlIDs,keyToIdMap,colorKeyToIdMapMap,gradientKeyToIdMapMap,lineEndingKeyToIdMapMap);
       tmp->exportToSBML(pLayout, copasimodelmap, sbmlIDs, keyToIdMap);
       writtenToSBML.insert(pLayout);
     }
 
   //check if a something needs to be deleted from the SBML data structures
   for (i = lol->size(); i > 0; --i)
     {
       SBase* object = lol->get((unsigned int) i - 1);
 
       if (writtenToSBML.find(object) == writtenToSBML.end())
         {
           lol->remove((unsigned int) i - 1);
           pdelete(object);
 
           //TODO: delete from map
           //the object and every object it contains need to be removed from the
           //map.
           //For now I do not implement this since layout object are not added to the
           //map in the first place.
         }
     }
 }

const std::string & CListOfLayouts::getKey ( )

Definition at line 69 of file CListOfLayouts.cpp.

References mKey.

Referenced by exportToSBML().

 {
   return mKey;
 }

const CCopasiVector< CLGlobalRenderInformation >& CListOfLayouts::getListOfGlobalRenderInformationObjects ( ) const

inline

Definition at line 63 of file CListOfLayouts.h.

References mvGlobalRenderInformationObjects.

Referenced by CQNewMainWindow::addGlobalRenderInfoItemsToList(), test000097::addGlobalRenderInformation(), CQLayoutScene::initializeResolver(), SBMLDocumentLoader::readListOfLayouts(), CCopasiXML::saveLayoutList(), CQNewMainWindow::slotRenderInfoChanged(), CQLayoutView::slotRenderInformationChanged(), CCopasiXMLParser::GlobalRenderInformationElement::start(), CQGLLayoutPainter::update(), updateRenderInformationList(), and CQNewMainWindow::updateRenderInformationList().

64 {return this->mvGlobalRenderInformationObjects;};

CListOfLayouts::mvGlobalRenderInformationObjects

CCopasiVector< CLGlobalRenderInformation > mvGlobalRenderInformationObjects

Definition: CListOfLayouts.h:34

CCopasiVector< CLGlobalRenderInformation >& CListOfLayouts::getListOfGlobalRenderInformationObjects ( )

inline

Definition at line 66 of file CListOfLayouts.h.

References mvGlobalRenderInformationObjects.

67 {return this->mvGlobalRenderInformationObjects;};

CListOfLayouts::mvGlobalRenderInformationObjects

CCopasiVector< CLGlobalRenderInformation > mvGlobalRenderInformationObjects

Definition: CListOfLayouts.h:34

CLGlobalRenderInformation * CListOfLayouts::getRenderInformation ( size_t index )

Returns a pointer to the global render information object with the given index. If the index is invalid, NULL is returned.

Definition at line 225 of file CListOfLayouts.cpp.

References mvGlobalRenderInformationObjects, and CCopasiVector< T >::size().

Referenced by CQNewMainWindow::addGlobalRenderInfoItemsToList(), CQNewMainWindow::slotRenderInfoChanged(), and CQNewMainWindow::updateRenderInformationList().

 {
   if (index < this->mvGlobalRenderInformationObjects.size())
     {
       return this->mvGlobalRenderInformationObjects[index];
     }
 
   return NULL;
 }

const CLGlobalRenderInformation * CListOfLayouts::getRenderInformation ( size_t index ) const

Returns a const pointer to the global render information object with the given index. If the index is invalid, NULL is returned.

Definition at line 239 of file CListOfLayouts.cpp.

References mvGlobalRenderInformationObjects, and CCopasiVector< T >::size().

 {
   if (index < this->mvGlobalRenderInformationObjects.size())
     {
       return this->mvGlobalRenderInformationObjects[index];
     }
 
   return NULL;
 }

Member Data Documentation

std::string CListOfLayouts::mKey

private

Definition at line 32 of file CListOfLayouts.h.

Referenced by getKey(), and ~CListOfLayouts().

CCopasiVector<CLGlobalRenderInformation> CListOfLayouts::mvGlobalRenderInformationObjects

private

Definition at line 34 of file CListOfLayouts.h.

Referenced by addGlobalRenderInformation(), exportToSBML(), getListOfGlobalRenderInformationObjects(), and getRenderInformation().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation