diff --git a/Modules/QtWidgets/include/QmitkDataStorageComboBox.h b/Modules/QtWidgets/include/QmitkDataStorageComboBox.h index 1dd4cbc7a9..9e468327ac 100644 --- a/Modules/QtWidgets/include/QmitkDataStorageComboBox.h +++ b/Modules/QtWidgets/include/QmitkDataStorageComboBox.h @@ -1,243 +1,232 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QmitkDataStorageComboBox_h #define QmitkDataStorageComboBox_h #include // Own Includes #include "mitkDataNode.h" #include "mitkDataStorage.h" #include "mitkNodePredicateBase.h" #include "mitkWeakPointer.h" // Toolkit Includes #include #include -// Forward Declartions - /// /// \ingroup QmitkModule /// \class QmitkDataStorageComboBox /// \author Michael Mueller /// \version 4.0 /// \date 2009-02-09 /// \ingroup Widgets /// \brief Displays all or a subset (defined by a predicate) of nodes of the Data Storage. /// -/// Dont forget that this class inherits from QComboBox and you can therefore use the whole API of QComboBox. /// class MITKQTWIDGETS_EXPORT QmitkDataStorageComboBox : public QComboBox { - //#CLASS-MACROS,FRIENDS Q_OBJECT - //#CTORS/DTOR public: /// /// \brief Ctor for an empty combobox. Use setDataStorage and setPredicate afterwards. /// - QmitkDataStorageComboBox(QWidget *parent = nullptr, bool _AutoSelectNewNodes = false); + QmitkDataStorageComboBox(QWidget *parent = nullptr, bool autoSelectNewNodes = false); /// - /// \brief Ctor for constructing QmitkDataStorageComboBox with given DataStorageComboBox and given _Predicate. + /// \brief Ctor for constructing QmitkDataStorageComboBox with given DataStorageComboBox and given predicate. /// - QmitkDataStorageComboBox(mitk::DataStorage *_DataStorage, - const mitk::NodePredicateBase *_Predicate, + QmitkDataStorageComboBox(mitk::DataStorage *dataStorage, + const mitk::NodePredicateBase *predicate, QWidget *parent = nullptr, - bool _AutoSelectNewNodes = false); + bool autoSelectNewNodes = false); /// /// \brief Standard Dtor. Nothing to do here. /// ~QmitkDataStorageComboBox() override; /// - /// \brief Seaches for a given node and returns a valid index or -1 if the node was not found. + /// \brief Searches for a given node and returns a valid index or -1 if the node was not found. /// - virtual int Find(const mitk::DataNode *_DataNode) const; + virtual int Find(const mitk::DataNode *dataNode) const; - //#PUBLIC GETTER public: /// /// \brief Get the DataStorage this ComboBox listens to. /// mitk::DataStorage::Pointer GetDataStorage() const; /// - /// \brief Return the predicate (may be nullptr) that is responsible for the _DataNode selection of this ComboBox. + /// \brief Return the predicate (may be nullptr) that is responsible for the dataNode selection of this ComboBox. /// const mitk::NodePredicateBase::ConstPointer GetPredicate() const; /// - /// \brief Returns the _DataNode at Index index or 0 if the index is out of bounds. + /// \brief Returns the dataNode at Index index or 0 if the index is out of bounds. /// virtual mitk::DataNode::Pointer GetNode(int index) const; /// - /// \brief Returns the selected _DataNode or 0 if there is none. + /// \brief Returns the selected dataNode or 0 if there is none. /// virtual mitk::DataNode::Pointer GetSelectedNode() const; /// /// \brief Returns all nodes that are stored in this combobox. /// mitk::DataStorage::SetOfObjects::ConstPointer GetNodes() const; /// /// Returns the AutoSelectNewItems. /// \see SetAutoSelectNewItems /// virtual bool GetAutoSelectNewItems(); - //#PUBLIC SETTER public: /// /// \brief Set the DataStorage this ComboBox should listen to. /// - /// If DataStorage is 0 nothing will be shown. If DataStorage is re-set the combobox will be resetted. + /// If DataStorage is 0 nothing will be shown. If DataStorage is reset the combobox will be reset. void SetDataStorage(mitk::DataStorage *dataStorage); /// /// \brief Set the predicate for this ComboBox. (QmitkDataStorageComboBox is now owner of the predicate) /// - /// If predicate is nullptr all nodes will be selected. If predicate changes the whole combobox will be resetted. - void SetPredicate(const mitk::NodePredicateBase *_Predicate); + /// If predicate is nullptr all nodes will be selected. If predicate changes the whole combobox will be reset. + void SetPredicate(const mitk::NodePredicateBase *predicate); /// - /// Adds a node to the ComboBox. Gets called everytime a DataStorage Add Event was thrown. + /// Adds a node to the ComboBox. Gets called every time a DataStorage Add Event was thrown. /// - virtual void AddNode(const mitk::DataNode *_DataNode); + virtual void AddNode(const mitk::DataNode *dataNode); /// /// Removes a node from the ComboBox at a specified index (if the index exists). Gets called when a DataStorage Remove /// Event was thrown. /// virtual void RemoveNode(int index); /// /// Removes a node from the ComboBox. Gets called when a DataStorage Remove Event was thrown. /// - virtual void RemoveNode(const mitk::DataNode *_DataNode); + virtual void RemoveNode(const mitk::DataNode *dataNode); /// - /// Set a _DataNode in the ComboBox at the specified index (if the index exists). + /// Set a dataNode in the ComboBox at the specified index (if the index exists). /// Internally the method just calls RemoveNode(unsigned int) /// - virtual void SetNode(int index, const mitk::DataNode *_DataNode); + virtual void SetNode(int index, const mitk::DataNode *dataNode); /// - /// Replaces a _DataNode in the combobox by an _OtherDataNode. + /// Replaces a dataNode in the combobox by an otherDataNode. /// Internally the method just calls SetNode(unsigned int, mitk::DataNode*) /// - virtual void SetNode(const mitk::DataNode *_DataNode, const mitk::DataNode *_OtherDataNode); + virtual void SetNode(const mitk::DataNode *dataNode, const mitk::DataNode *otherDataNode); /// /// Sets AutoSelectNewItems flag. If set to true new Nodes will be automatically selected. Default is false. /// - virtual void SetAutoSelectNewItems(bool _AutoSelectNewItems); + virtual void SetAutoSelectNewItems(bool autoSelectNewItems); /// /// \brief Called when a node is deleted or the name property of the node was modified. Calls RemoveNode or SetNode /// then. /// virtual void OnDataNodeDeleteOrModified(const itk::Object *caller, const itk::EventObject &event); signals: /// - /// \brief Throw a signal when the _DataNode selection changed. + /// \brief Throw a signal when the data node selection changed. /// void OnSelectionChanged(const mitk::DataNode *); - //#PROTECTED GETTER protected: /// /// \brief Checks if the given index is within the range of the m_Nodes vector. /// bool HasIndex(unsigned int index) const; - //#PROTECTED SETTER protected slots: /// /// \brief Slot for signal when the user selects another item. /// void OnCurrentIndexChanged(int); - //#PUBLIC SETTER public slots: /// /// \brief Slot for signal when user wants to set a node as current selected node. /// void SetSelectedNode(mitk::DataNode::Pointer item); protected: /// - /// \brief Inserts a new node at the given index. If the index does not exist, the _DataNode is simply appended to the - /// combobox. + /// \brief Inserts a new node at the given index. If the index does not exist, + /// the data node is simply appended to the combobox. /// /// This function is used by AddNode() and SetNode() because they just to the same: /// 1. If node is replaced (that is when index exists), /// the itk::Event observer will be removed /// 2. Check Node against Predicate /// 3. Register for itk::Events on the node /// 4. Insert Node and show in combobox - virtual void InsertNode(int index, const mitk::DataNode *_DataNode); + virtual void InsertNode(int index, const mitk::DataNode *dataNode); /// - /// \brief Init-function this class with the given dataStorage and _Predicate. This function is called by all ctors. + /// \brief Init-function this class with the given data storage and predicate. This function is called by all ctors. /// void Init(); /// - /// \brief Reset function whenever datastorage or predicate changes. + /// \brief Reset function whenever data storage or predicate changes. /// virtual void Reset(); protected: - //#PROTECTED MEMBER VARS /// /// Pointer to the DataStorage from which the nodes are selected (remember: in BlueBerry there /// might be more than one DataStorage). /// mitk::WeakPointer m_DataStorage; /// - /// \brief Holds the predicate that is responsible for the _DataNode selection of this ComboBox. - /// If the predicate is 0, every _DataNode will be selected. + /// \brief Holds the predicate that is responsible for the dataNode selection of this ComboBox. + /// If the predicate is 0, every dataNode will be selected. /// mitk::NodePredicateBase::ConstPointer m_Predicate; /// - /// Holds all selected Nodes. Dont hold smart pointer as we are in a GUI class. + /// Holds all selected Nodes. Don't hold smart pointer as we are in a GUI class. /// std::vector m_Nodes; /// - /// \brief Holds the tags of the node-modified observers. (must be updated everytime m_Nodes changes) + /// \brief Holds the tags of the node-modified observers. (must be updated every time m_Nodes changes) /// std::vector m_NodesModifiedObserverTags; /// - /// \brief Holds the tags of the node-modified observers. (must be updated everytime m_Nodes changes) + /// \brief Holds the tags of the node-modified observers. (must be updated every time m_Nodes changes) /// std::vector m_NodesDeleteObserverTags; /// - /// \brief Maps a a specific node to (Name-)property. This is needed because we have to find the assiociated node + /// \brief Maps a a specific node to (Name-)property. This is needed because we have to find the associated node /// whenever the name property of a node changed. /// std::map m_PropertyToNode; /// /// \brief Event function guard. Each function which is called by an event mechanism /// first checks if this is true in order to avoid endless loops. bool m_BlockEvents; /// /// \brief If set to "true" new Nodes will be automatically selected. bool m_AutoSelectNewNodes; }; #endif // QmitkDataStorageComboBox_h diff --git a/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp b/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp index 9a498c94df..7eca972391 100644 --- a/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp +++ b/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp @@ -1,435 +1,425 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkDataStorageComboBox.h" #include -//#CTORS/DTOR - -QmitkDataStorageComboBox::QmitkDataStorageComboBox(QWidget *parent, bool _AutoSelectNewNodes) +QmitkDataStorageComboBox::QmitkDataStorageComboBox(QWidget *parent, bool autoSelectNewNodes) : QComboBox(parent), m_DataStorage(nullptr), m_Predicate(nullptr), m_BlockEvents(false), - m_AutoSelectNewNodes(_AutoSelectNewNodes) + m_AutoSelectNewNodes(autoSelectNewNodes) { this->Init(); } -QmitkDataStorageComboBox::QmitkDataStorageComboBox(mitk::DataStorage *_DataStorage, - const mitk::NodePredicateBase *_Predicate, +QmitkDataStorageComboBox::QmitkDataStorageComboBox(mitk::DataStorage *dataStorage, + const mitk::NodePredicateBase *predicate, QWidget *parent, - bool _AutoSelectNewNodes) + bool autoSelectNewNodes) : QComboBox(parent), m_DataStorage(nullptr), - m_Predicate(_Predicate), + m_Predicate(predicate), m_BlockEvents(false), - m_AutoSelectNewNodes(_AutoSelectNewNodes) + m_AutoSelectNewNodes(autoSelectNewNodes) { // make connections, fill combobox this->Init(); - this->SetDataStorage(_DataStorage); + this->SetDataStorage(dataStorage); } QmitkDataStorageComboBox::~QmitkDataStorageComboBox() { // if there was an old storage, remove listeners if (!m_DataStorage.IsExpired()) { auto dataStorage = m_DataStorage.Lock(); dataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1(this, &QmitkDataStorageComboBox::AddNode)); dataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1(this, &QmitkDataStorageComboBox::RemoveNode)); } - // we have lots of observers to nodes and their name properties, this get's ugly if nodes live longer than the box + // we have lots of observers to nodes and their name properties, this gets ugly if nodes live longer than the box while (m_Nodes.size() > 0) RemoveNode(0); } -//#PUBLIC GETTER +int QmitkDataStorageComboBox::Find(const mitk::DataNode *dataNode) const +{ + int index = -1; + + auto nodeIt = std::find(m_Nodes.begin(), m_Nodes.end(), dataNode); + + if (nodeIt != m_Nodes.end()) + index = std::distance(m_Nodes.begin(), nodeIt); + + return index; +} + mitk::DataStorage::Pointer QmitkDataStorageComboBox::GetDataStorage() const { return m_DataStorage.Lock(); } const mitk::NodePredicateBase::ConstPointer QmitkDataStorageComboBox::GetPredicate() const { return m_Predicate.GetPointer(); } mitk::DataNode::Pointer QmitkDataStorageComboBox::GetNode(int index) const { return (this->HasIndex(index)) ? m_Nodes.at(index) : nullptr; } mitk::DataNode::Pointer QmitkDataStorageComboBox::GetSelectedNode() const { if (this->count() == 0) return nullptr; int currentIndex = this->currentIndex(); return currentIndex >= 0 ? this->GetNode(currentIndex) : nullptr; } mitk::DataStorage::SetOfObjects::ConstPointer QmitkDataStorageComboBox::GetNodes() const { - mitk::DataStorage::SetOfObjects::Pointer _SetOfObjects = mitk::DataStorage::SetOfObjects::New(); + mitk::DataStorage::SetOfObjects::Pointer setOfObjects = mitk::DataStorage::SetOfObjects::New(); for (auto it = m_Nodes.begin(); it != m_Nodes.end(); ++it) { - _SetOfObjects->push_back(*it); + setOfObjects->push_back(*it); } - return _SetOfObjects.GetPointer(); + return setOfObjects.GetPointer(); } bool QmitkDataStorageComboBox::GetAutoSelectNewItems() { return m_AutoSelectNewNodes; } -//#PUBLIC SETTER -void QmitkDataStorageComboBox::SetDataStorage(mitk::DataStorage *_DataStorage) +void QmitkDataStorageComboBox::SetDataStorage(mitk::DataStorage *dataStorage) { - auto dataStorage = m_DataStorage.Lock(); + auto currentDataStorage = m_DataStorage.Lock(); // reset only if datastorage really changed - if (dataStorage.GetPointer() != _DataStorage) + if (currentDataStorage.GetPointer() != dataStorage) { // if there was an old storage, remove listeners - if (dataStorage.IsNotNull()) + if (currentDataStorage.IsNotNull()) { - dataStorage->AddNodeEvent.RemoveListener( + currentDataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1(this, - &QmitkDataStorageComboBox::AddNode)); + &QmitkDataStorageComboBox::AddNode)); - dataStorage->RemoveNodeEvent.RemoveListener( - mitk::MessageDelegate1( - this, &QmitkDataStorageComboBox::RemoveNode)); + currentDataStorage->RemoveNodeEvent.RemoveListener( + mitk::MessageDelegate1(this, + &QmitkDataStorageComboBox::RemoveNode)); } // set new storage - m_DataStorage = _DataStorage; + m_DataStorage = dataStorage; // if there is a new storage, add listeners if (!m_DataStorage.IsExpired()) { - dataStorage = m_DataStorage.Lock(); + currentDataStorage = m_DataStorage.Lock(); - dataStorage->AddNodeEvent.AddListener( + currentDataStorage->AddNodeEvent.AddListener( mitk::MessageDelegate1(this, - &QmitkDataStorageComboBox::AddNode)); + &QmitkDataStorageComboBox::AddNode)); - dataStorage->RemoveNodeEvent.AddListener( - mitk::MessageDelegate1( - this, &QmitkDataStorageComboBox::RemoveNode)); + currentDataStorage->RemoveNodeEvent.AddListener( + mitk::MessageDelegate1(this, + &QmitkDataStorageComboBox::RemoveNode)); } // reset predicate to reset the combobox this->Reset(); } } -void QmitkDataStorageComboBox::SetPredicate(const mitk::NodePredicateBase *_Predicate) +void QmitkDataStorageComboBox::SetPredicate(const mitk::NodePredicateBase *predicate) { - if (m_Predicate != _Predicate) + if (m_Predicate != predicate) { - m_Predicate = _Predicate; + m_Predicate = predicate; this->Reset(); } } -void QmitkDataStorageComboBox::AddNode(const mitk::DataNode *_DataNode) +void QmitkDataStorageComboBox::AddNode(const mitk::DataNode *dataNode) { - // this is an event function, make sure that we didnt call ourself + // this is an event function, make sure that we didn't call ourself if (!m_BlockEvents) { m_BlockEvents = true; - // pass a -1 to the InsertNode function in order to append the datatreenode to the end - this->InsertNode(-1, _DataNode); + // pass a -1 to the InsertNode function in order to append the datatree node to the end + this->InsertNode(-1, dataNode); m_BlockEvents = false; } } void QmitkDataStorageComboBox::RemoveNode(int index) { if (this->HasIndex(index)) { - //# remove itk::Event observer - mitk::DataNode *_DataNode = m_Nodes.at(index); + // remove itk::Event observer + mitk::DataNode *dataNode = m_Nodes.at(index); // get name property first - mitk::BaseProperty *nameProperty = _DataNode->GetProperty("name"); + mitk::BaseProperty *nameProperty = dataNode->GetProperty("name"); // if prop exists remove modified listener if (nameProperty) { nameProperty->RemoveObserver(m_NodesModifiedObserverTags[index]); // remove name property map - m_PropertyToNode.erase(_DataNode); + m_PropertyToNode.erase(dataNode); } // then remove delete listener on the node itself - _DataNode->RemoveObserver(m_NodesDeleteObserverTags[index]); + dataNode->RemoveObserver(m_NodesDeleteObserverTags[index]); // remove observer tags from lists m_NodesModifiedObserverTags.erase(m_NodesModifiedObserverTags.begin() + index); m_NodesDeleteObserverTags.erase(m_NodesDeleteObserverTags.begin() + index); // remove node from node vector m_Nodes.erase(m_Nodes.begin() + index); // remove node name from combobox this->removeItem(index); } } -void QmitkDataStorageComboBox::RemoveNode(const mitk::DataNode *_DataNode) +void QmitkDataStorageComboBox::RemoveNode(const mitk::DataNode *dataNode) { - // this is an event function, make sure that we didnt call ourself + // this is an event function, make sure that we didn't call ourself if (!m_BlockEvents) { m_BlockEvents = true; - this->RemoveNode(this->Find(_DataNode)); + this->RemoveNode(this->Find(dataNode)); m_BlockEvents = false; } } -void QmitkDataStorageComboBox::SetNode(int index, const mitk::DataNode *_DataNode) +void QmitkDataStorageComboBox::SetNode(int index, const mitk::DataNode *dataNode) { if (this->HasIndex(index)) { - this->InsertNode(index, _DataNode); + this->InsertNode(index, dataNode); } } -void QmitkDataStorageComboBox::SetNode(const mitk::DataNode *_DataNode, const mitk::DataNode *_OtherDataNode) +void QmitkDataStorageComboBox::SetNode(const mitk::DataNode *dataNode, const mitk::DataNode *otherDataNode) { - this->SetNode(this->Find(_DataNode), _OtherDataNode); + this->SetNode(this->Find(dataNode), otherDataNode); } -void QmitkDataStorageComboBox::SetAutoSelectNewItems(bool _AutoSelectNewItems) +void QmitkDataStorageComboBox::SetAutoSelectNewItems(bool autoSelectNewItems) { - m_AutoSelectNewNodes = _AutoSelectNewItems; + m_AutoSelectNewNodes = autoSelectNewItems; } void QmitkDataStorageComboBox::OnDataNodeDeleteOrModified(const itk::Object *caller, const itk::EventObject &event) { if (!m_BlockEvents) { m_BlockEvents = true; // check if we have a modified event (if not it is a delete event) const itk::ModifiedEvent *modifiedEvent = dynamic_cast(&event); // when node was modified reset text if (modifiedEvent) { - const mitk::BaseProperty *_NameProperty = dynamic_cast(caller); + const mitk::BaseProperty *nameProperty = dynamic_cast(caller); // node name changed, set it // but first of all find associated node for (auto it = m_PropertyToNode.begin(); it != m_PropertyToNode.end(); ++it) { // property is found take node - if (it->second == _NameProperty) + if (it->second == nameProperty) { // looks strange but when calling setnode with the same node, that means the node gets updated this->SetNode(it->first, it->first); break; } } } else { - const mitk::DataNode *_ConstDataNode = dynamic_cast(caller); - if (_ConstDataNode) + const mitk::DataNode *constDataNode = dynamic_cast(caller); + if (constDataNode) // node will be deleted, remove it - this->RemoveNode(_ConstDataNode); + this->RemoveNode(constDataNode); } m_BlockEvents = false; } } -void QmitkDataStorageComboBox::SetSelectedNode(mitk::DataNode::Pointer item) -{ - int index = this->Find(item); - if (index == -1) - { - MITK_INFO << "QmitkDataStorageComboBox: item not available"; - } - else - { - this->setCurrentIndex(index); - } -} - -//#PROTECTED GETTER bool QmitkDataStorageComboBox::HasIndex(unsigned int index) const { return (m_Nodes.size() > 0 && index < m_Nodes.size()); } -int QmitkDataStorageComboBox::Find(const mitk::DataNode *_DataNode) const -{ - int index = -1; - - auto nodeIt = std::find(m_Nodes.begin(), m_Nodes.end(), _DataNode); - - if (nodeIt != m_Nodes.end()) - index = std::distance(m_Nodes.begin(), nodeIt); - - return index; -} - -//#PROTECTED SETTER void QmitkDataStorageComboBox::OnCurrentIndexChanged(int index) { if (index >= 0 && index < this->count()) emit OnSelectionChanged(this->GetSelectedNode()); if (index == -1) emit OnSelectionChanged(nullptr); } -void QmitkDataStorageComboBox::InsertNode(int index, const mitk::DataNode *_DataNode) +void QmitkDataStorageComboBox::SetSelectedNode(mitk::DataNode::Pointer item) +{ + int index = this->Find(item); + if (index == -1) + { + MITK_INFO << "QmitkDataStorageComboBox: item not available"; + } + else + { + this->setCurrentIndex(index); + } +} + +void QmitkDataStorageComboBox::InsertNode(int index, const mitk::DataNode *dataNode) { // check new or updated node first - if (m_Predicate.IsNotNull() && !m_Predicate->CheckNode(_DataNode)) + if (m_Predicate.IsNotNull() && !m_Predicate->CheckNode(dataNode)) return; bool addNewNode = false; bool insertNewNode = false; bool changedNode = false; // if this->HasIndex(index), then a node shall be updated if (this->HasIndex(index)) { // if we really have another node at this position then ... - if (_DataNode != m_Nodes.at(index)) + if (dataNode != m_Nodes.at(index)) { // ... remove node, then proceed as usual this->RemoveNode(index); insertNewNode = true; } else changedNode = true; } // otherwise a new node shall be added, let index point to the element after the last element else { index = m_Nodes.size(); addNewNode = true; } // const cast because we need non const nodes - mitk::DataNode *_NonConstDataNode = const_cast(_DataNode); - mitk::BaseProperty *nameProperty = _NonConstDataNode->GetProperty("name"); - + mitk::DataNode *nonConstDataNode = const_cast(dataNode); + std::string itemName = "unnamed node"; if (!changedNode) { - // break on duplicated nodes (that doesnt make sense to have duplicates in the combobox) - if (this->Find(_DataNode) != -1) + // break on duplicated nodes (that doesn't make sense to have duplicates in the combobox) + if (this->Find(dataNode) != -1) return; // add modified observer itk::MemberCommand::Pointer modifiedCommand = itk::MemberCommand::New(); modifiedCommand->SetCallbackFunction(this, &QmitkDataStorageComboBox::OnDataNodeDeleteOrModified); - // !!!! add modified observer for the name - /// property of the node because this is the only thing we are interested in !!!!! + + // add modified observer for the name property + // first try retrieving the name property of the data node + mitk::BaseProperty *nameProperty = nonConstDataNode->GetProperty("name"); if (nameProperty) { m_NodesModifiedObserverTags.push_back(nameProperty->AddObserver(itk::ModifiedEvent(), modifiedCommand)); - m_PropertyToNode[_NonConstDataNode] = nameProperty; + m_PropertyToNode[nonConstDataNode] = nameProperty; + itemName = nameProperty->GetValueAsString(); } // if there is no name node save an invalid value for the observer tag (-1) else m_NodesModifiedObserverTags.push_back(-1); // add delete observer itk::MemberCommand::Pointer deleteCommand = itk::MemberCommand::New(); deleteCommand->SetCallbackFunction(this, &QmitkDataStorageComboBox::OnDataNodeDeleteOrModified); - m_NodesDeleteObserverTags.push_back(_NonConstDataNode->AddObserver(itk::DeleteEvent(), modifiedCommand)); + m_NodesDeleteObserverTags.push_back(nonConstDataNode->AddObserver(itk::DeleteEvent(), modifiedCommand)); } // add node to the vector if (addNewNode) - m_Nodes.push_back(_NonConstDataNode); + m_Nodes.push_back(nonConstDataNode); else if (insertNewNode) - m_Nodes.insert(m_Nodes.begin() + index, _NonConstDataNode); - - // ... and to the combobox - std::string _NonConstDataNodeName = "unnamed node"; - // _NonConstDataNodeName is "unnamed node" so far, change it if there is a name property in the node - if (nameProperty) - _NonConstDataNodeName = nameProperty->GetValueAsString(); + m_Nodes.insert(m_Nodes.begin() + index, nonConstDataNode); if (addNewNode) { - this->addItem(QString::fromStdString(_NonConstDataNodeName)); + this->addItem(QString::fromStdString(itemName)); // select new node if m_AutoSelectNewNodes is true or if we have just added the first node if (m_AutoSelectNewNodes || m_Nodes.size() == 1) this->setCurrentIndex(index); } else { // update text in combobox - this->setItemText(index, QString::fromStdString(_NonConstDataNodeName)); + this->setItemText(index, QString::fromStdString(itemName)); } } void QmitkDataStorageComboBox::Init() { connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(OnCurrentIndexChanged(int))); } void QmitkDataStorageComboBox::Reset() { // remove all nodes first while (!m_Nodes.empty()) { // remove last node - // explicietely calling RemoveNode of QmitkDataStorageComboBox since derived classes may prevent the removal of all + // explicitly calling RemoveNode of QmitkDataStorageComboBox since derived classes may prevent the removal of all // nodes in their respective RemoveNode implementation. This is happening for example in // QmitkDataStorageComboBoxWithSelectNone. QmitkDataStorageComboBox::RemoveNode(m_Nodes.size() - 1); } // clear combobox this->clear(); if (!m_DataStorage.IsExpired()) { auto dataStorage = m_DataStorage.Lock(); mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects; // select all if predicate == nullptr if (m_Predicate.IsNotNull()) setOfObjects = dataStorage->GetSubset(m_Predicate); else setOfObjects = dataStorage->GetAll(); // add all found nodes for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin(); nodeIt != setOfObjects->End(); - ++nodeIt) // for each _DataNode + ++nodeIt) // for each dataNode { // add node to the node vector and to the combobox this->AddNode(nodeIt.Value().GetPointer()); } } }