diff --git a/Modules/QtWidgets/include/QmitkSingleNodeSelectionWidget.h b/Modules/QtWidgets/include/QmitkSingleNodeSelectionWidget.h
index 44130cb7e6..72c61fbad6 100644
--- a/Modules/QtWidgets/include/QmitkSingleNodeSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkSingleNodeSelectionWidget.h
@@ -1,97 +1,98 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkSingleNodeSelectionWidget_h
#define QmitkSingleNodeSelectionWidget_h
#include <MitkQtWidgetsExports.h>
#include <ui_QmitkSingleNodeSelectionWidget.h>
#include <mitkDataStorage.h>
#include <mitkWeakPointer.h>
#include <mitkNodePredicateBase.h>
#include <QmitkAbstractNodeSelectionWidget.h>
#include <QmitkNodeSelectionButton.h>
class QmitkAbstractDataStorageModel;
/**
* @class QmitkSingleNodeSelectionWidget
* @brief Widget that represents a node selection of (max) one node. It acts like a button. Clicking on it
* allows to change the selection.
*
* @remark This class provides a public function 'SetAutoSelectNewNodes' that can be used to enable
* the auto selection mode (default is false).
* The user of this class calling this function has to make sure that the base-class Q_SIGNAL
* 'CurrentSelectionChanged', which will be emitted by this function, is already
* connected to a receiving slot, if the initial valid auto selection should not get lost.
*/
class MITKQTWIDGETS_EXPORT QmitkSingleNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
{
Q_OBJECT
public:
explicit QmitkSingleNodeSelectionWidget(QWidget* parent = nullptr);
mitk::DataNode::Pointer GetSelectedNode() const;
bool GetAutoSelectNewNodes() const;
using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
public Q_SLOTS:
void SetCurrentSelectedNode(mitk::DataNode* selectedNode);
/**
* Sets the auto selection mode (default is false).
* If auto select is true and the following conditions are fulfilled, the widget will
* select a node automatically from the data storage:
* - a data storage is set
* - data storage contains at least one node that matches the given predicate
* - no selection is set
*
* @remark Enabling the auto selection mode by calling 'SetAutoSelectNewNodes(true)'
* will directly emit a 'QmitkSingleNodeSelectionWidget::CurrentSelectionChanged' Q_SIGNAL
* if a valid auto selection was made.
* If this initial emission should not get lost, auto selection mode needs to be enabled after this
* selection widget has been connected via the 'QmitkSingleNodeSelectionWidget::CurrentSelectionChanged'
* Q_SIGNAL to a receiving function.
*/
void SetAutoSelectNewNodes(bool autoSelect);
protected Q_SLOTS:
virtual void OnClearSelection();
protected:
void ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection) override;
bool eventFilter(QObject *obj, QEvent *ev) override;
void EditSelection();
void UpdateInfo() override;
void OnDataStorageChanged() override;
void OnNodeAddedToStorage(const mitk::DataNode* node) override;
+ void OnNodePredicateChanged() override;
void AutoSelectNodes();
/** Helper function that gets a suitable auto selected node from the datastorage that fits to the predicate settings.
@param ignoreNodes You may pass a list of nodes that must not be chosen as auto selected node. */
mitk::DataNode::Pointer DetermineAutoSelectNode(const NodeList& ignoreNodes = {});
/** See documentation of SetAutoSelectNewNodes for details*/
bool m_AutoSelectNodes;
Ui_QmitkSingleNodeSelectionWidget m_Controls;
};
#endif
diff --git a/Modules/QtWidgets/src/QmitkSingleNodeSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkSingleNodeSelectionWidget.cpp
index fc30ea2679..d4c462c133 100644
--- a/Modules/QtWidgets/src/QmitkSingleNodeSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkSingleNodeSelectionWidget.cpp
@@ -1,240 +1,245 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSingleNodeSelectionWidget.h"
#include <mitkNodePredicateFunction.h>
#include <mitkNodePredicateAnd.h>
#include <QmitkNodeSelectionDialog.h>
#include <QmitkNodeDetailsDialog.h>
#include <QmitkStyleManager.h>
#include <QMouseEvent>
QmitkSingleNodeSelectionWidget::QmitkSingleNodeSelectionWidget(QWidget* parent)
: QmitkAbstractNodeSelectionWidget(parent)
, m_AutoSelectNodes(false)
{
m_Controls.setupUi(this);
m_Controls.btnSelect->installEventFilter(this);
m_Controls.btnSelect->setVisible(true);
m_Controls.btnClear->setVisible(false);
m_Controls.btnClear->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/times.svg")));
this->UpdateInfo();
connect(m_Controls.btnClear, SIGNAL(clicked(bool)), this, SLOT(OnClearSelection()));
}
void QmitkSingleNodeSelectionWidget::ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
{
if (newInternalSelection.empty())
{
if (m_AutoSelectNodes)
{
auto autoSelectedNode = this->DetermineAutoSelectNode(oldInternalSelection);
if (autoSelectedNode.IsNotNull())
{
newInternalSelection.append(autoSelectedNode);
}
}
}
else if (newInternalSelection.size()>1)
{
//this widget only allows one internal selected node.
newInternalSelection = { newInternalSelection.front() };
}
}
void QmitkSingleNodeSelectionWidget::OnClearSelection()
{
if (m_IsOptional)
{
this->SetCurrentSelection({});
}
this->UpdateInfo();
}
mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::GetSelectedNode() const
{
mitk::DataNode::Pointer result;
auto selection = GetCurrentInternalSelection();
if (!selection.empty())
{
result = selection.front();
}
return result;
}
bool QmitkSingleNodeSelectionWidget::eventFilter(QObject *obj, QEvent *ev)
{
if (obj == m_Controls.btnSelect)
{
if (ev->type() == QEvent::MouseButtonRelease)
{
auto mouseEv = dynamic_cast<QMouseEvent*>(ev);
if (!mouseEv)
{
return false;
}
if (mouseEv->button() == Qt::LeftButton)
{
if (this->isEnabled())
{
this->EditSelection();
return true;
}
}
else
{
auto selection = this->CompileEmitSelection();
if (!selection.empty())
{
QmitkNodeDetailsDialog infoDialog(selection, this);
infoDialog.exec();
return true;
}
}
}
}
return false;
}
void QmitkSingleNodeSelectionWidget::EditSelection()
{
QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
dialog->SetDataStorage(m_DataStorage.Lock());
dialog->SetNodePredicate(m_NodePredicate);
dialog->SetCurrentSelection(this->GetCurrentInternalSelection());
dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
dialog->SetSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.btnSelect->setChecked(true);
if (dialog->exec())
{
this->HandleChangeOfInternalSelection(dialog->GetSelectedNodes());
}
m_Controls.btnSelect->setChecked(false);
delete dialog;
}
void QmitkSingleNodeSelectionWidget::UpdateInfo()
{
if (this->GetSelectedNode().IsNull())
{
if (m_IsOptional)
{
m_Controls.btnSelect->SetNodeInfo(m_EmptyInfo);
}
else
{
m_Controls.btnSelect->SetNodeInfo(m_InvalidInfo);
}
m_Controls.btnSelect->SetSelectionIsOptional(m_IsOptional);
m_Controls.btnClear->setVisible(false);
}
else
{
m_Controls.btnClear->setVisible(m_IsOptional);
}
m_Controls.btnSelect->SetSelectedNode(this->GetSelectedNode());
}
void QmitkSingleNodeSelectionWidget::SetCurrentSelectedNode(mitk::DataNode* selectedNode)
{
NodeList selection;
if (selectedNode)
{
selection.append(selectedNode);
}
this->SetCurrentSelection(selection);
}
void QmitkSingleNodeSelectionWidget::OnDataStorageChanged()
{
this->AutoSelectNodes();
}
void QmitkSingleNodeSelectionWidget::OnNodeAddedToStorage(const mitk::DataNode* /*node*/)
{
this->AutoSelectNodes();
}
+void QmitkSingleNodeSelectionWidget::OnNodePredicateChanged()
+{
+ this->AutoSelectNodes();
+}
+
bool QmitkSingleNodeSelectionWidget::GetAutoSelectNewNodes() const
{
return m_AutoSelectNodes;
}
void QmitkSingleNodeSelectionWidget::SetAutoSelectNewNodes(bool autoSelect)
{
m_AutoSelectNodes = autoSelect;
this->AutoSelectNodes();
}
void QmitkSingleNodeSelectionWidget::AutoSelectNodes()
{
if (this->GetSelectedNode().IsNull() && m_AutoSelectNodes)
{
auto autoNode = this->DetermineAutoSelectNode();
if (autoNode.IsNotNull())
{
this->HandleChangeOfInternalSelection({ autoNode });
}
}
}
mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::DetermineAutoSelectNode(const NodeList& ignoreNodes)
{
mitk::DataNode::Pointer result;
auto storage = m_DataStorage.Lock();
if (storage.IsNotNull())
{
auto ignoreCheck = [ignoreNodes](const mitk::DataNode * node)
{
bool result = true;
for (const auto& ignoreNode : ignoreNodes)
{
if (node == ignoreNode)
{
result = false;
break;
}
}
return result;
};
mitk::NodePredicateFunction::Pointer isNotIgnoredNode = mitk::NodePredicateFunction::New(ignoreCheck);
mitk::NodePredicateBase::Pointer predicate = isNotIgnoredNode.GetPointer();
if (m_NodePredicate.IsNotNull())
{
predicate = mitk::NodePredicateAnd::New(m_NodePredicate.GetPointer(), predicate.GetPointer()).GetPointer();
}
result = storage->GetNode(predicate);
}
return result;
}