diff --git a/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp b/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp index a8888f8042..4e9483f1ab 100644 --- a/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp +++ b/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp @@ -1,208 +1,217 @@ /*=================================================================== 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. ===================================================================*/ // render window manager UI module #include "QmitkRenderWindowDataModel.h" #include "QmitkCustomVariants.h" +#include "QmitkEnums.h" QmitkRenderWindowDataModel::QmitkRenderWindowDataModel(QObject* parent /*= nullptr*/) : QAbstractTableModel(parent) { // nothing here } QmitkRenderWindowDataModel::~QmitkRenderWindowDataModel() { if (m_DataStorage.IsNotNull()) { m_DataStorage->ChangedNodeEvent.RemoveListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); m_DataStorage->RemoveNodeEvent.RemoveListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); } } int QmitkRenderWindowDataModel::rowCount(const QModelIndex &parent /*= QModelIndex()*/) const { if (parent.isValid()) { return 0; } return static_cast(m_TempLayerStack.size()); } int QmitkRenderWindowDataModel::columnCount(const QModelIndex &parent /*= QModelIndex()*/) const { if (parent.isValid()) { return 0; } return 2; } QVariant QmitkRenderWindowDataModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) { return QVariant(); } if ((index.row()) < static_cast(m_TempLayerStack.size())) { RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_TempLayerStack.begin(); std::advance(layerStackIt, index.row()); mitk::DataNode* dataNode = layerStackIt->second; - if (Qt::CheckStateRole == role && 0 == index.column()) + + if (0 == index.column()) { - bool visibility = false; - dataNode->GetVisibility(visibility, m_BaseRenderer); - if (visibility) + if (Qt::CheckStateRole == role) { - return Qt::Checked; + bool visibility = false; + dataNode->GetVisibility(visibility, m_BaseRenderer); + if (visibility) + { + return Qt::Checked; + } + else + { + return Qt::Unchecked; + } } - else + else if (Qt::ToolTipRole == role) { - return Qt::Unchecked; + return QVariant("Show/hide data node."); } } - else if (Qt::DisplayRole == role && 1 == index.column()) + else if (1 == index.column()) { - return QVariant(QString::fromStdString(dataNode->GetName())); - } - else if (Qt::ToolTipRole == role) - { - if (0 == index.column()) + if (Qt::DisplayRole == role) { - return QVariant("Show/hide data node."); + return QVariant(QString::fromStdString(dataNode->GetName())); } - else if (1 == index.column()) + else if (Qt::ToolTipRole == role) { return QVariant("Name of the data node."); } - } - else if (Qt::UserRole == role) - { - // user role always returns a reference to the data node, - // which can be used to modify the data node in the data storage - return QVariant::fromValue(dataNode); + else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role) + { + // user role always returns a reference to the data node, + // which can be used to modify the data node in the data storage + return QVariant::fromValue(dataNode); + } + else if (QmitkDataNodeRole == role) + { + return QVariant::fromValue(mitk::DataNode::Pointer(dataNode)); + } } } return QVariant(); } Qt::ItemFlags QmitkRenderWindowDataModel::flags(const QModelIndex &index) const { Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable; if (0 == index.column()) { flags |= Qt::ItemIsUserCheckable; } return flags; } QVariant QmitkRenderWindowDataModel::headerData(int section, Qt::Orientation orientation, int role) const { if (Qt::Horizontal == orientation && Qt::DisplayRole == role) { if (0 == section) { return QVariant("Visibility"); } else if (1 == section) { return QVariant("Data node"); } } return QVariant(); } bool QmitkRenderWindowDataModel::setData(const QModelIndex &index, const QVariant &value, int role /*= Qt::EditRole*/) { if (!index.isValid()) { return false; } if ((index.row()) < static_cast(m_TempLayerStack.size())) { RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_TempLayerStack.begin(); std::advance(layerStackIt, index.row()); mitk::DataNode* dataNode = layerStackIt->second; if (Qt::CheckStateRole == role) { Qt::CheckState newCheckState = static_cast(value.toInt()); if (Qt::PartiallyChecked == newCheckState || Qt::Checked == newCheckState) { dataNode->SetVisibility(true, m_BaseRenderer); } else { dataNode->SetVisibility(false, m_BaseRenderer); } emit dataChanged(index, index); mitk::RenderingManager::GetInstance()->RequestUpdate(m_BaseRenderer->GetRenderWindow()); return true; } } return false; } void QmitkRenderWindowDataModel::SetDataStorage(mitk::DataStorage::Pointer dataStorage) { if (m_DataStorage != dataStorage) { // given data storage is a new data storage if (m_DataStorage.IsNotNull()) { // remove listener from old data storage m_DataStorage->ChangedNodeEvent.RemoveListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); m_DataStorage->RemoveNodeEvent.RemoveListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); } // set the new data storage m_DataStorage = dataStorage; // register new data storage listener if (m_DataStorage.IsNotNull()) { m_DataStorage->ChangedNodeEvent.AddListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); m_DataStorage->RemoveNodeEvent.AddListener(mitk::MessageDelegate1(this, &QmitkRenderWindowDataModel::DataChanged)); } DataChanged(nullptr); } } void QmitkRenderWindowDataModel::SetCurrentRenderer(std::string renderWindowName) { m_BaseRenderer = mitk::BaseRenderer::GetByName(renderWindowName); if (m_DataStorage.IsNotNull()) { DataChanged(nullptr); } } void QmitkRenderWindowDataModel::DataChanged(const mitk::DataNode* /*dataNode*/) { if (m_BaseRenderer.IsNotNull()) { // update the model, so that the table will be filled with the nodes information of the new data storage beginResetModel(); // get the current layer stack of the given base renderer m_TempLayerStack = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, m_BaseRenderer, true); endResetModel(); } } diff --git a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h index e08edafbce..4706e0eec1 100644 --- a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h +++ b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h @@ -1,108 +1,110 @@ /*=================================================================== 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 QMITKRENDERWINDOWMANIPULATORWIDGET_H #define QMITKRENDERWINDOWMANIPULATORWIDGET_H // render window manager UI module #include "MitkRenderWindowManagerUIExports.h" #include "ui_QmitkRenderWindowManipulatorWidget.h" // render window manager module #include #include #include // qt #include /** * The QmitkRenderWindowManipulatorWidget offers a GUI to manipulate the base renderer / render windows of the MITK workbench. * The widgets supports adding a layer to an active render window, moving layers up and down, removing layers, * resetting layers (hiding them) or removing all layers at once. * * In order to use this widget, a (e.g.) plugin has to set the controlled renderer, which will be forwarded to * a render window layer controller and a render window view direction controller. * The plugin also has to provide a Q_SLOT that is connected to the 'AddLayerButtonClicked'-Q_SIGNAL of this widget. * This allows for a customized add-layer functionality. */ class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkRenderWindowManipulatorWidget : public QWidget { Q_OBJECT public: QmitkRenderWindowManipulatorWidget(mitk::DataStorage::Pointer dataStorage, QWidget* parent = nullptr); /** * @brief Set the controlled base renderer. */ void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer); /** * @brief Set the currently selected render window * * @param renderWindowId the text inside the combo box */ void SetActiveRenderWindow(const QString &renderWindowId); /** * @brief Use the RenderWindowLayerController to insert the given data node into the currently active render window. * The new node is placed on top of all existing layer nodes in that render window. * * @param dataNode The data node that should be inserted. */ void AddLayer(mitk::DataNode* dataNode); /** * @brief Use the RenderWindowLayerController to insert the given data node into all controlled render windows. * The new node is placed on top of all existing layer nodes in the render window. * * @param dataNode The data node that should be inserted. */ void AddLayerToAllRenderer(mitk::DataNode* dataNode); /** * @brief Use the RenderWindowLayerController to hide the given data node in the currently active render window. * * @param dataNode The data node that should be hid. */ void HideDataNodeInAllRenderer(const mitk::DataNode* dataNode); + QItemSelectionModel* GetSelectionModel(); + Q_SIGNALS: void AddLayerButtonClicked(); private Q_SLOTS: void RemoveLayer(); void SetAsBaseLayer(); void MoveLayer(const QString &direction); void ResetRenderer(); void ClearRenderer(); void ChangeViewDirection(const QString &viewDirection); private: void Init(); void SetUpConnections(); Ui::QmitkRenderWindowManipulatorWidget m_Controls; mitk::DataStorage::Pointer m_DataStorage; std::unique_ptr m_RenderWindowDataModel; std::unique_ptr m_RenderWindowLayerController; std::unique_ptr m_RenderWindowViewDirectionController; }; #endif // QMITKRENDERWINDOWMANIPULATORWIDGET_H diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp index c8ecd4bee7..1de0bccc30 100644 --- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp +++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp @@ -1,216 +1,221 @@ /*=================================================================== 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. ===================================================================*/ // render window manager UI module #include "QmitkRenderWindowManipulatorWidget.h" #include "QmitkCustomVariants.h" // mitk core #include // qt #include QmitkRenderWindowManipulatorWidget::QmitkRenderWindowManipulatorWidget(mitk::DataStorage::Pointer dataStorage, QWidget* parent /*=nullptr*/) : QWidget(parent) , m_DataStorage(dataStorage) { Init(); } void QmitkRenderWindowManipulatorWidget::Init() { // create GUI from the Qt Designer's .ui file m_Controls.setupUi(this); // initialize the render window layer controller and the render window view direction controller // and set the controller renderer (in constructor) and the data storage m_RenderWindowLayerController = std::make_unique(); m_RenderWindowViewDirectionController = std::make_unique(); m_RenderWindowLayerController->SetDataStorage(m_DataStorage); m_RenderWindowViewDirectionController->SetDataStorage(m_DataStorage); // create a new model m_RenderWindowDataModel = std::make_unique(this); m_RenderWindowDataModel->SetDataStorage(m_DataStorage); m_Controls.renderWindowTableView->setModel(m_RenderWindowDataModel.get()); m_Controls.renderWindowTableView->setEditTriggers(QAbstractItemView::NoEditTriggers); m_Controls.renderWindowTableView->horizontalHeader()->setStretchLastSection(true); m_Controls.renderWindowTableView->setSelectionBehavior(QAbstractItemView::SelectRows); m_Controls.renderWindowTableView->setSelectionMode(QAbstractItemView::SingleSelection); SetUpConnections(); } void QmitkRenderWindowManipulatorWidget::SetUpConnections() { // signal to signal connection connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SIGNAL(AddLayerButtonClicked())); connect(m_Controls.pushButtonRemoveLayer, SIGNAL(clicked()), this, SLOT(RemoveLayer())); connect(m_Controls.pushButtonSetAsBaseLayer, SIGNAL(clicked()), this, SLOT(SetAsBaseLayer())); QSignalMapper* udSignalMapper = new QSignalMapper(this); udSignalMapper->setMapping(m_Controls.pushButtonMoveUp, QString("up")); udSignalMapper->setMapping(m_Controls.pushButtonMoveDown, QString("down")); connect(udSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(MoveLayer(const QString&))); connect(m_Controls.pushButtonMoveUp, SIGNAL(clicked()), udSignalMapper, SLOT(map())); connect(m_Controls.pushButtonMoveDown, SIGNAL(clicked()), udSignalMapper, SLOT(map())); connect(m_Controls.pushButtonResetRenderer, SIGNAL(clicked()), this, SLOT(ResetRenderer())); connect(m_Controls.pushButtonClearRenderer, SIGNAL(clicked()), this, SLOT(ClearRenderer())); QSignalMapper* changeViewDirectionSignalMapper = new QSignalMapper(this); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonAxial, QString("axial")); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonCoronal, QString("coronal")); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonSagittal, QString("sagittal")); connect(changeViewDirectionSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(ChangeViewDirection(const QString&))); connect(m_Controls.radioButtonAxial, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); connect(m_Controls.radioButtonCoronal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); connect(m_Controls.radioButtonSagittal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); } void QmitkRenderWindowManipulatorWidget::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer) { m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer); m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer); } void QmitkRenderWindowManipulatorWidget::SetActiveRenderWindow(const QString &renderWindowId) { std::string currentRendererName = renderWindowId.toStdString(); m_RenderWindowDataModel->SetCurrentRenderer(currentRendererName); mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(currentRendererName); if (nullptr == selectedRenderer) { return; } mitk::SliceNavigationController::ViewDirection viewDirection = selectedRenderer->GetSliceNavigationController()->GetDefaultViewDirection(); switch (viewDirection) { case mitk::SliceNavigationController::Axial: m_Controls.radioButtonAxial->setChecked(true); break; case mitk::SliceNavigationController::Frontal: m_Controls.radioButtonCoronal->setChecked(true); break; case mitk::SliceNavigationController::Sagittal: m_Controls.radioButtonSagittal->setChecked(true); break; default: break; } } void QmitkRenderWindowManipulatorWidget::AddLayer(mitk::DataNode* dataNode) { m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, m_RenderWindowDataModel->GetCurrentRenderer()); } void QmitkRenderWindowManipulatorWidget::AddLayerToAllRenderer(mitk::DataNode* dataNode) { m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, nullptr); } void QmitkRenderWindowManipulatorWidget::HideDataNodeInAllRenderer(const mitk::DataNode* dataNode) { m_RenderWindowLayerController->HideDataNodeInAllRenderer(dataNode); } +QItemSelectionModel* QmitkRenderWindowManipulatorWidget::GetSelectionModel() +{ + return m_Controls.renderWindowTableView->selectionModel(); +} + void QmitkRenderWindowManipulatorWidget::RemoveLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant qvariantDataNode = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); if (qvariantDataNode.canConvert()) { mitk::DataNode* dataNode = qvariantDataNode.value(); m_RenderWindowLayerController->RemoveLayerNode(dataNode, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } } } void QmitkRenderWindowManipulatorWidget::SetAsBaseLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant qvariantDataNode = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); if (qvariantDataNode.canConvert()) { mitk::DataNode* dataNode = qvariantDataNode.value(); m_RenderWindowLayerController->SetBaseDataNode(dataNode, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } } } void QmitkRenderWindowManipulatorWidget::MoveLayer(const QString &direction) { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant qvariantDataNode = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); if (qvariantDataNode.canConvert()) { mitk::DataNode* dataNode = qvariantDataNode.value(); const mitk::BaseRenderer* selectedRenderer = m_RenderWindowDataModel->GetCurrentRenderer(); bool success = false; if ("up" == direction) { success = m_RenderWindowLayerController->MoveNodeUp(dataNode, selectedRenderer); if (success) { // node has been successfully moved up m_Controls.renderWindowTableView->selectRow(selectedIndex.row() - 1); } } else { success = m_RenderWindowLayerController->MoveNodeDown(dataNode, selectedRenderer); if (success) { // node has been successfully moved down m_Controls.renderWindowTableView->selectRow(selectedIndex.row() + 1); } } } } } void QmitkRenderWindowManipulatorWidget::ResetRenderer() { m_RenderWindowLayerController->ResetRenderer(true, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } void QmitkRenderWindowManipulatorWidget::ClearRenderer() { m_RenderWindowLayerController->ResetRenderer(false, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } void QmitkRenderWindowManipulatorWidget::ChangeViewDirection(const QString &viewDirection) { m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), m_RenderWindowDataModel->GetCurrentRenderer()); } diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp index 1307b4045e..bbdaab98cd 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp @@ -1,114 +1,119 @@ /*=================================================================== 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. ===================================================================*/ // render window manager plugin #include "QmitkRenderWindowManagerView.h" // blueberry #include #include // mitk core #include #include const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager"; void QmitkRenderWindowManagerView::SetFocus() { // nothing here } void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent) { // create GUI widgets m_Controls.setupUi(parent); // add custom render window manager UI widget to the 'renderWindowManagerTab' m_RenderWindowManipulatorWidget = new QmitkRenderWindowManipulatorWidget(GetDataStorage(), parent); m_RenderWindowManipulatorWidget->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget")); m_Controls.verticalLayout->addWidget(m_RenderWindowManipulatorWidget); SetControlledRenderer(); for (const auto& renderer : m_ControlledRenderer) { m_Controls.comboBoxRenderWindowSelection->addItem(renderer->GetName()); } OnRenderWindowSelectionChanged(m_Controls.comboBoxRenderWindowSelection->itemText(0)); connect(m_Controls.comboBoxRenderWindowSelection, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(OnRenderWindowSelectionChanged(const QString&))); connect(m_RenderWindowManipulatorWidget, SIGNAL(AddLayerButtonClicked()), this, SLOT(OnAddLayerButtonClicked())); } void QmitkRenderWindowManagerView::SetControlledRenderer() { const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows = mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); mitk::BaseRenderer* baseRenderer = nullptr; for (const auto &renderWindow : allRegisteredRenderWindows) { baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow); if (nullptr != baseRenderer) { m_ControlledRenderer.push_back(baseRenderer); } } m_RenderWindowManipulatorWidget->SetControlledRenderer(m_ControlledRenderer); } void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId) { m_RenderWindowManipulatorWidget->SetActiveRenderWindow(renderWindowId); } void QmitkRenderWindowManagerView::OnAddLayerButtonClicked() { QList nodes = GetDataManagerSelection(); for (mitk::DataNode* dataNode : nodes) { if (nullptr != dataNode) { m_RenderWindowManipulatorWidget->AddLayer(dataNode); // get child nodes of the current node mitk::DataStorage::SetOfObjects::ConstPointer derivedNodes = GetDataStorage()->GetDerivations(dataNode, nullptr, false); for (mitk::DataStorage::SetOfObjects::ConstIterator it = derivedNodes->Begin(); it != derivedNodes->End(); ++it) { m_RenderWindowManipulatorWidget->AddLayer(it->Value()); } } } } +QItemSelectionModel* QmitkRenderWindowManagerView::GetDataNodeSelectionModel() const +{ + return m_RenderWindowManipulatorWidget->GetSelectionModel(); +} + void QmitkRenderWindowManagerView::NodeAdded(const mitk::DataNode* node) { bool global = false; node->GetBoolProperty("globalObject_RWM", global); if (global) { // initially insert new point set node into the node list of all render windows // the node object of a new point set won't be visible due to its "helper object" property set to true m_RenderWindowManipulatorWidget->AddLayerToAllRenderer(const_cast(node)); } else { // initially set new node as invisible in all render windows // this way, each single renderer overwrites the common renderer and the node is invisible // until it is inserted into the node list of a render windows m_RenderWindowManipulatorWidget->HideDataNodeInAllRenderer(node); } } diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h index ba9743fb77..110f24c50d 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h @@ -1,82 +1,91 @@ /*=================================================================== 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 QMITKRENDERWINDOWMANAGERVIEW_H #define QMITKRENDERWINDOWMANAGERVIEW_H // render window manager plugin #include "ui_QmitkRenderWindowManagerControls.h" // render window manager UI module #include // blueberry #include // qt #include /** * @brief RenderWindowManager */ class QmitkRenderWindowManagerView : public QmitkAbstractView { Q_OBJECT public: static const std::string VIEW_ID; protected: virtual void SetFocus() override; virtual void CreateQtPartControl(QWidget* parent) override; private Q_SLOTS: /** * @brief Called when the user changes the render window selection in the combo box. * * @param renderWindowId The text inside the combo box. */ void OnRenderWindowSelectionChanged(const QString &renderWindowId); /** * @brief Called when the 'AddLayer'-button of he render window manipulator widget has been pushed. */ void OnAddLayerButtonClicked(); private: void SetControlledRenderer(); - + /** + * @brief Provide a QItemSelectionModel, which supports the data role 'QmitkDataNodeRole' (\see QmitkRenderWindowDataModel). + * + * The provided QItemSelectionModel is used in the QmitkAbstractView-base class as the selection model of + * the selection provider (\see QmitkAbstractView::SetSelectionProvider()). + * The default selection provider is a QmitkDataNodeSelectionProvider. Each time a selection in the provided QItemSeletionModel is changed, + * a selection changed event is fired. All plugins (views), that subclass the QmitkAbstractView will be infored about the selection changed via + * the OnSelectionChanged-function. + */ + QItemSelectionModel* GetDataNodeSelectionModel() const override; /** * @brief Reacts to a node that has been added to the data storage. * 1. Insert new node into the node list of all render windows, if it is an "globalObject_RWM"-node. * or else * 2. Set data node invisible in all render windows, as soon as the node is added to the data storage. */ void NodeAdded(const mitk::DataNode* node) override; // the Qt parent of our GUI QWidget* m_Parent; Ui::QmitkRenderWindowManagerControls m_Controls; QmitkRenderWindowManipulatorWidget* m_RenderWindowManipulatorWidget; RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; #endif // QMITKRENDERWINDOWMANAGERVIEW_H