#include <CQAutolayoutWizard.h>

Inheritance diagram for CQSelectionWizardPage:

Collaboration diagram for CQSelectionWizardPage:

Public Member Functions
	CQSelectionWizardPage (const CModel &model)

void	fillContainers (std::set< const CCompartment * > &compartments, std::set< const CReaction * > &reactions, std::set< const CMetab * > &species) const

Protected Slots
void	slotCreateCompartments (int state)

void	slotItemChanged (QTreeWidgetItem *pItem, int column)

Protected Member Functions
void	fillTree (const CModel &model)

Protected Attributes
bool	mCreateCompartmentElements

QTreeWidgetItem *	mpCompartmentsItem

QTreeWidgetItem *	mpReactionsItem

QTreeWidget *	mpSelectionTree

Detailed Description

This is the first page of the wizard. It displays a tree where the user can select the objects that should be included in the layout.

Definition at line 82 of file CQAutolayoutWizard.h.

Constructor & Destructor Documentation

CQSelectionWizardPage::CQSelectionWizardPage ( const CModel & model )

Definition at line 91 of file CQAutolayoutWizard.cpp.

References fillTree(), mpCompartmentsItem, mpReactionsItem, mpSelectionTree, slotCreateCompartments(), and slotItemChanged().

                                                                 :
   QWizardPage()
   , mCreateCompartmentElements(false)
   , mpSelectionTree(new QTreeWidget)
   , mpCompartmentsItem(new QTreeWidgetItem((QTreeWidget*)NULL, QStringList(QString(tr("Compartments")))))
   , mpReactionsItem(new QTreeWidgetItem((QTreeWidget*)NULL, QStringList(QString(tr("Reactions")))))
 {
   this->setTitle(tr("Model Element Selection"));
   this->setSubTitle("Please select the model elements for which you want to create layout elements.\nPlease Note the the \"All ...\" elements only turn their immediate children on or off.");
   QVBoxLayout* pLayout = new QVBoxLayout;
   this->setLayout(pLayout);
   pLayout->addWidget(this->mpSelectionTree);
   this->fillTree(model);
   QCheckBox* pCheckBox = new QCheckBox("create compartment elements");
   pCheckBox->setChecked(false);
   connect(pCheckBox, SIGNAL(stateChanged(int)), this, SLOT(slotCreateCompartments(int)));
   pLayout->addWidget(pCheckBox);
   this->mpSelectionTree->setColumnCount(1);
   this->mpSelectionTree->setHeaderLabel(tr("Elements"));
   // add a top level element for the compartments
   // add a top level element for the reactions
   QList<QTreeWidgetItem*> items;
   items.append(this->mpCompartmentsItem);
   items.append(this->mpReactionsItem);
   this->mpSelectionTree->insertTopLevelItems(0, items);
   connect(this->mpSelectionTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotItemChanged(QTreeWidgetItem*, int)));
 }

Member Function Documentation

void CQSelectionWizardPage::fillContainers	(	std::set< const CCompartment * > &	compartments,
		std::set< const CReaction * > &	reactions,
		std::set< const CMetab * > &	species
	)		const

Checks which elements have been selected in the tree and fills the containers that are passed in with those elements.

Definition at line 495 of file CQAutolayoutWizard.cpp.

References CQModelElementTreeWidgetItem::getObject(), mpCompartmentsItem, and mpReactionsItem.

 {
   // clear all containers
   compartments.clear();
   reactions.clear();
   species.clear();
 
   if (this->mpCompartmentsItem->childCount() > 0)
     {
       QTreeWidgetItem* pItem = this->mpCompartmentsItem->child(0);
       unsigned int i = 0, iMax = pItem->childCount();
       unsigned int j, jMax;
       const CMetab* pMetab = NULL;
       QTreeWidgetItem *pItem2 = NULL, *pChild = NULL, *pChild2 = NULL;
       const CCompartment* pCompartment = NULL;
       CQModelElementTreeWidgetItem* pModelItem = NULL;
 
       while (i < iMax)
         {
           pChild = pItem->child(i);
           assert(pChild != NULL);
 
           if ((pChild->flags() & Qt::ItemIsUserCheckable) && pChild->checkState(0) == Qt::Checked)
             {
               pModelItem = dynamic_cast<CQModelElementTreeWidgetItem*>(pItem->child(i));
               assert(pModelItem != NULL);
               pCompartment = dynamic_cast<const CCompartment*>(pModelItem->getObject());
               assert(pCompartment != NULL);
               compartments.insert(pCompartment);
             }
 
           pItem2 = pChild->child(0);
 
           // get the All species item
           if (pItem2 == NULL)
             {
               ++i;
               continue;
             }
 
           j = 0;
           jMax = pItem2->childCount();
 
           while (j < jMax)
             {
               pChild2 = pItem2->child(j);
 
               if ((pChild2->flags() & Qt::ItemIsUserCheckable) && pChild2->checkState(0) == Qt::Checked)
                 {
                   pModelItem = dynamic_cast<CQModelElementTreeWidgetItem*>(pItem2->child(j));
                   assert(pModelItem != NULL);
                   pMetab = dynamic_cast<const CMetab*>(pModelItem->getObject());
                   assert(pMetab != NULL);
                   species.insert(pMetab);
                 }
 
               ++j;
             }
 
           ++i;
         }
 
       // now we add the reactions
     }
 
   if (this->mpReactionsItem->childCount() > 0)
     {
       // there should be only one child (All reactions)
       assert(this->mpReactionsItem->childCount() == 1);
       QTreeWidgetItem* pItem = this->mpReactionsItem->child(0), *pChild = NULL;
       CQModelElementTreeWidgetItem* pModelItem = NULL;
       unsigned int i = 0, iMax;
       iMax = pItem->childCount();
       const CReaction* pReaction = NULL;
 
       while (i < iMax)
         {
           pChild = pItem->child(i);
 
           if ((pChild->flags() & Qt::ItemIsUserCheckable) && pChild->checkState(0) == Qt::Checked)
             {
               pModelItem = dynamic_cast<CQModelElementTreeWidgetItem*>(pChild);
               assert(pModelItem != NULL);
               pReaction = dynamic_cast<const CReaction*>(pModelItem->getObject());
               assert(pReaction != NULL);
               reactions.insert(pReaction);
             }
 
           ++i;
         }
     }
 }

void CQSelectionWizardPage::fillTree ( const CModel & model )

protected

Definition at line 392 of file CQAutolayoutWizard.cpp.

References CModel::getCompartments(), CModelEntity::getKey(), CReaction::getKey(), CCompartment::getMetabolites(), CModel::getMetabolites(), CReaction::getObjectDisplayName(), CMetab::getObjectDisplayName(), CCopasiObject::getObjectDisplayName(), CModel::getReactions(), mpCompartmentsItem, mpReactionsItem, and CCopasiVector< T >::size().

Referenced by CQSelectionWizardPage().

 {
   const CCopasiVectorNS < CCompartment >& compartments = model.getCompartments();
   const CCopasiVector< CMetab >& metabs = model.getMetabolites();
   const CCopasiVectorNS < CReaction >& reactions = model.getReactions();
 
   if (compartments.size() > 0 && metabs.size() > 0)
     {
       // make all items checkable but the ones for the compartments
       // and the ones for All compartments
       // check all checkable items
 
       // add the compartments
       // first we have to add two items to the top level items that we can use to
       // specify that we want to select all children in a list
       QTreeWidgetItem* pItem = new QTreeWidgetItem(QStringList(QString(tr("All Compartments"))));
       pItem->setFlags(pItem->flags() & (!Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
       this->mpCompartmentsItem->addChild(pItem);
       // add all compartments to the item
       QList<QTreeWidgetItem*> children, children2;
       unsigned int i = 0, iMax = compartments.size();
       QTreeWidgetItem *pChild1;
       const CCompartment* pCompartment = NULL;
       QTreeWidgetItem *pItem2 = NULL, *pItem3 = NULL;
       const CCopasiVectorNS<CMetab>* pMetabs = NULL;
       unsigned int j, jMax;
       const CMetab* pMetab = NULL;
 
       while (i < iMax)
         {
           pCompartment = compartments[i];
           assert(pCompartment != NULL);
           pChild1 = new CQModelElementTreeWidgetItem(QStringList(QString(pCompartment->getObjectDisplayName().c_str())), pCompartment->getKey());
           pChild1->setFlags(pChild1->flags() & (!Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
           // add an item to select all children
           pMetabs = &pCompartment->getMetabolites();
           assert(pMetabs != NULL);
 
           if (pMetabs->size() > 0)
             {
               pItem2 = new QTreeWidgetItem(QStringList(QString(tr("All Metabolites in Compartment"))));
               pItem2->setFlags(pItem2->flags() | (Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
               pItem2->setCheckState(0, Qt::Checked);
               pChild1->addChild(pItem2);
               // now we add all metabolites
               j = 0;
               jMax = pMetabs->size();
 
               while (j < jMax)
                 {
                   pMetab = (*pMetabs)[j];
                   assert(pMetab != NULL);
                   pItem3 = new CQModelElementTreeWidgetItem(QStringList(QString(pMetab->getObjectDisplayName().c_str())), pMetab->getKey());
                   pItem3->setFlags(pItem3->flags() | (Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
                   pItem3->setCheckState(0, Qt::Checked);
                   children2.append(pItem3);
                   ++j;
                 }
 
               pItem2->addChildren(children2);
               children2.clear();
             }
 
           children.append(pChild1);
           ++i;
         }
 
       pItem->addChildren(children);
 
       if (reactions.size() > 0)
         {
           // top level item to select all reactions
           pItem = new QTreeWidgetItem(QStringList(QString(tr("All Reactions"))));
           pItem->setFlags(pItem->flags() | (Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
           pItem->setCheckState(0, Qt::Checked);
           this->mpReactionsItem->addChild(pItem);
           // now we add all reactions
           i = 0;
           iMax = reactions.size();
           const CReaction* pReaction = NULL;
 
           while (i < iMax)
             {
               pReaction = reactions[i];
               assert(pReaction != NULL);
               pChild1 = new CQModelElementTreeWidgetItem(QStringList(QString(pReaction->getObjectDisplayName().c_str())), pReaction->getKey());
               pChild1->setFlags(pChild1->flags() | (Qt::ItemIsUserCheckable | Qt::ItemIsEnabled));
               pChild1->setCheckState(0, Qt::Checked);
               // TODO add the substrates and products to the reactions
               children2.append(pChild1);
               ++i;
             }
 
           pItem->addChildren(children2);
         }
     }
 }

void CQSelectionWizardPage::slotCreateCompartments ( int state )

protectedslot

Definition at line 339 of file CQAutolayoutWizard.cpp.

References mCreateCompartmentElements, mpCompartmentsItem, mpSelectionTree, and slotItemChanged().

Referenced by CQSelectionWizardPage().

 {
   // set the flags on the compartment items and the All items in compartments
   // to be checkable but leave them unchecked
   disconnect(this->mpSelectionTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotItemChanged(QTreeWidgetItem*, int)));
 
   if (state == Qt::Checked)
     {
       this->mCreateCompartmentElements = true;
       QTreeWidgetItem* pItem = this->mpCompartmentsItem->child(0);
 
       if (pItem != NULL)
         {
           pItem->setFlags(pItem->flags() | Qt::ItemIsUserCheckable);
           pItem->setCheckState(0, Qt::Unchecked);
           // now we do the same on all the children of this item
           unsigned int i = 0, iMax = pItem->childCount();
 
           while (i < iMax)
             {
               pItem->child(i)->setFlags(pItem->child(i)->flags() | Qt::ItemIsUserCheckable);
               pItem->child(i)->setCheckState(0, Qt::Unchecked);
               ++i;
             }
         }
     }
   else
     {
       this->mCreateCompartmentElements = false;
       this->mpCompartmentsItem->setFlags(this->mpCompartmentsItem->flags() & (~Qt::ItemIsUserCheckable));
       this->mpCompartmentsItem->setData(0, Qt::CheckStateRole, QVariant());
       QTreeWidgetItem* pItem = this->mpCompartmentsItem->child(0);
 
       if (pItem != NULL)
         {
           pItem->setFlags(pItem->flags() & (~Qt::ItemIsUserCheckable));
           pItem->setData(0, Qt::CheckStateRole, QVariant());
           // now we do the same on all the children of this item
           unsigned int i = 0, iMax = pItem->childCount();
 
           while (i < iMax)
             {
               pItem->child(i)->setFlags(pItem->child(i)->flags() & (~Qt::ItemIsUserCheckable));
               pItem->child(i)->setData(0, Qt::CheckStateRole, QVariant());
               ++i;
             }
         }
     }
 
   connect(this->mpSelectionTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotItemChanged(QTreeWidgetItem*, int)));
 }

void CQSelectionWizardPage::slotItemChanged	(	QTreeWidgetItem *	pItem,
		int	column
	)

protectedslot

Definition at line 119 of file CQAutolayoutWizard.cpp.

References mpCompartmentsItem, mpReactionsItem, mpSelectionTree, and slotItemChanged().

Referenced by CQSelectionWizardPage(), slotCreateCompartments(), and slotItemChanged().

 {
   disconnect(this->mpSelectionTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotItemChanged(QTreeWidgetItem*, int)));
   QTreeWidgetItem* pParent = pItem->parent();
   assert(pParent != NULL);
   bool found = false;
 
   if (this->mpCompartmentsItem->childCount() > 0)
     {
       // check if it was the "All compartments" entry
       QTreeWidgetItem* pChild = this->mpCompartmentsItem->child(0);
 
       if (pItem == pChild)
         {
           // we have to select or deselect all immediate children
           found = true;
           unsigned int i = 0, iMax = pItem->childCount();
           Qt::CheckState state = pItem->checkState(0);
 
           while (i < iMax)
             {
               pItem->child(i)->setCheckState(0, state);
               ++i;
             }
         }
       else
         {
           // check if it was one of the compartments entries
           // the "All metabolite" entry, or one of the metabolites
           int i = 0, iMax = pChild->childCount();
           QTreeWidgetItem* pAll = NULL;
 
           while (i < iMax && !found)
             {
               if (pItem == pChild->child(i))
                 {
                   // it is a compartment node
                   // , we might have to change the state of the parent
                   found = true;
                   unsigned int j = 0, jMax = pParent->childCount();
                   bool allSelected = true;
                   bool allUnselected = true;
 
                   while (j < jMax && (allSelected == true || allUnselected == true))
                     {
                       if (pParent->child(j)->checkState(0) == Qt::Checked)
                         {
                           allUnselected = false;
                         }
                       else if (pParent->child(j)->checkState(0) == Qt::Unchecked)
                         {
                           allSelected = false;
                         }
                       else
                         {
                           allSelected = false;
                           allUnselected = false;
                         }
 
                       ++j;
                     }
 
                   if (allSelected == true)
                     {
                       pParent->setCheckState(0, Qt::Checked);
                     }
                   else if (allUnselected == true)
                     {
                       pParent->setCheckState(0, Qt::Unchecked);
                     }
                   else
                     {
                       pParent->setCheckState(0, Qt::PartiallyChecked);
                     }
                 }
               else
                 {
                   pAll = pChild->child(i)->child(0);
 
                   if (pAll != NULL)
                     {
                       if (pItem == pAll)
                         {
                           // we have to select or deselect all immediate children
                           found = true;
                           unsigned int j = 0, jMax = pItem->childCount();
                           Qt::CheckState state = pItem->checkState(0);
 
                           while (j < jMax)
                             {
                               pItem->child(j)->setCheckState(0, state);
                               ++j;
                             }
                         }
                       else if (pAll == pParent)
                         {
                           found = true;
                           // a metabolites selection status has changed
                           // we have to change the state of the parent
                           unsigned int j = 0, jMax = pParent->childCount();
                           bool allSelected = true;
                           bool allUnselected = true;
 
                           while (j < jMax && (allSelected == true || allUnselected == true))
                             {
                               if (pParent->child(j)->checkState(0) == Qt::Checked)
                                 {
                                   allUnselected = false;
                                 }
                               else if (pParent->child(j)->checkState(0) == Qt::Unchecked)
                                 {
                                   allSelected = false;
                                 }
                               else
                                 {
                                   allSelected = false;
                                   allUnselected = false;
                                 }
 
                               ++j;
                             }
 
                           if (allSelected == true)
                             {
                               pParent->setCheckState(0, Qt::Checked);
                             }
                           else if (allUnselected == true)
                             {
                               pParent->setCheckState(0, Qt::Unchecked);
                             }
                           else
                             {
                               pParent->setCheckState(0, Qt::PartiallyChecked);
                             }
                         }
                     }
                 }
 
               ++i;
             }
         }
     }
 
   if (!found && this->mpReactionsItem->childCount() > 0)
     {
       // check if it was the "All reactions" entry
       QTreeWidgetItem* pChild = this->mpReactionsItem->child(0);
 
       if (pItem == pChild)
         {
           // we have to select or deselect all immediate children
           found = true;
           unsigned int j = 0, jMax = pItem->childCount();
           Qt::CheckState state = pItem->checkState(0);
 
           while (j < jMax)
             {
               pItem->child(j)->setCheckState(0, state);
               ++j;
             }
         }
       else
         {
           // check if it was one of the reaction entries
           int i = 0, iMax = pChild->childCount();
 
           while (i < iMax && !found)
             {
               if (pItem == pChild->child(i))
                 {
                   found = true;
                   // it is a reaction node
                   // , we might have to change the state of the parent
                   unsigned int j = 0, jMax = pParent->childCount();
                   bool allSelected = true;
                   bool allUnselected = true;
 
                   while (j < jMax && (allSelected == true || allUnselected == true))
                     {
                       if (pParent->child(j)->checkState(0) == Qt::Checked)
                         {
                           allUnselected = false;
                         }
                       else if (pParent->child(j)->checkState(0) == Qt::Unchecked)
                         {
                           allSelected = false;
                         }
                       else
                         {
                           allSelected = false;
                           allUnselected = false;
                         }
 
                       ++j;
                     }
 
                   if (allSelected == true)
                     {
                       pParent->setCheckState(0, Qt::Checked);
                     }
                   else if (allUnselected == true)
                     {
                       pParent->setCheckState(0, Qt::Unchecked);
                     }
                   else
                     {
                       pParent->setCheckState(0, Qt::PartiallyChecked);
                     }
                 }
 
               ++i;
             }
         }
     }
 
   assert(found == true);
   connect(this->mpSelectionTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotItemChanged(QTreeWidgetItem*, int)));
 }