diff --git a/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h b/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h index 09a95b8c52..c16f7cd1ad 100644 --- a/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h +++ b/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h @@ -1,69 +1,68 @@ /*=================================================================== 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 QMITKRENDERWINDOWDATAMODEL_H #define QMITKRENDERWINDOWDATAMODEL_H -// render window manager +// render window manager module #include "MitkRenderWindowManagerExports.h" #include "mitkRenderWindowLayerUtilities.h" -//mitk +//mitk core #include #include // qt #include /* -* @brief This class extends the 'QAbstractItemModel' to meet the specific requirements of the QmitkRenderWindowDataModel. +* @brief This class extends the 'QAbstractTableModel' to meet the specific requirements of the QmitkRenderWindowDataModel. */ class MITKRENDERWINDOWMANAGER_EXPORT QmitkRenderWindowDataModel : public QAbstractTableModel { Q_OBJECT public: QmitkRenderWindowDataModel(QObject* parent = nullptr); - virtual ~QmitkRenderWindowDataModel(); + ~QmitkRenderWindowDataModel(); ////////////////////////////////////////////////////////////////////////// /// overridden functions from QAbstractItemModel ////////////////////////////////////////////////////////////////////////// virtual Qt::ItemFlags flags(const QModelIndex &index) const override; virtual QVariant data(const QModelIndex &index, int role) const override; virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override; virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override; virtual int columnCount(const QModelIndex &parent = QModelIndex()) const override; virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override; ////////////////////////////////////////////////////////////////////////// /// end override ///////////////////////////////////////////////////////////////////////// - // currently not needed (uses data storage of the layer controller (e.g. for call of GetLayerStack)) void SetDataStorage(mitk::DataStorage::Pointer dataStorage); void SetCurrentRenderer(std::string rendererName); void DataChanged(const mitk::DataNode* dataNode); private: mitk::DataStorage::Pointer m_DataStorage; mitk::BaseRenderer::Pointer m_BaseRenderer; RenderWindowLayerUtilities::LayerStack m_TempLayerStack; }; #endif // QMITKRENDERWINDOWDATAMODEL_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h index 7691dbd68f..d956dcb101 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h +++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h @@ -1,128 +1,166 @@ /*=================================================================== 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 MITKRENDERWINDOWLAYERCONTROLLER_H #define MITKRENDERWINDOWLAYERCONTROLLER_H -// render window manager +// render window manager module #include "MitkRenderWindowManagerExports.h" +#include "mitkRenderWindowLayerUtilities.h" -// mitk +// mitk core #include #include #include namespace mitk { - /* - * TODO: really layer 0 (zero)? - * The base data node of a renderer is supposed to be on layer 0 (zero), which should be the lowest layer in a render window. + /** * * Functions with 'const mitk::BaseRenderer* renderer' have 'nullptr' as their default argument. Using the nullptr * these functions operate on all base renderer. */ class MITKRENDERWINDOWMANAGER_EXPORT RenderWindowLayerController { public: typedef std::vector RendererVector; RenderWindowLayerController(); - virtual ~RenderWindowLayerController(); /** - * @brief set the data storage on which to work + * @brief Set the data storage on which to work. */ void SetDataStorage(DataStorage::Pointer dataStorage); DataStorage::Pointer GetDataStorage() { return m_DataStorage; }; /** - * @brief set the controlled base renderer by specifying the corresponding render windows + * @brief Set the controlled base renderer by specifying the corresponding render windows. */ void SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows); /** - * @brief set the controlled base renderer + * @brief Set the controlled base renderer. */ void SetControlledRenderer(RendererVector controlledRenderer); RendererVector GetControlledRenderer() { return m_ControlledRenderer; }; // wrapper functions to modify the layer order / visibility of render window data /** - * @brief set the given node as the base node of the given renderer (nullptr = all renderer) + * @brief Set the given node as the base node of the given renderer. + * + * @param dataNode The data node whose layer is to be modified. + * @param renderer Pointer to the renderer instance for which the data node property should be modified. + * If it is a nullptr (default) all controlled renderer will be affected. */ void SetBaseDataNode(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief insert the given data node at the specified layer for the given renderer (nullptr = all renderer) + * @brief Insert the given data node at the specified layer for the given renderer. + * + * @param dataNode The data node that should be inserted. + * @param layer The layer value for the "layer" property of the data node (insertion level). + "layer = RenderWindowLayerUtilities::TOP_LAYER_INDEX" (default) inserts the given data node at the top of the node stack (topmost layer). + * @param renderer Pointer to the renderer instance for which the data node should be inserted. + * If it is a nullptr (default) all controlled renderer will be affected. * - * 'layer = -1' (default) inserts the given data node at the top of the node stack (topmost layer) - * new layer nodes have to have their 'fixedLayer' property set to true + * @post After a successful call, the "fixedLayer" and "visibility" property will be true and the "layer" property will be set correctly. */ - void InsertLayerNode(DataNode* dataNode, int layer = -1, const BaseRenderer* renderer = nullptr); + void InsertLayerNode(DataNode* dataNode, int layer = RenderWindowLayerUtilities::TOP_LAYER_INDEX, const BaseRenderer* renderer = nullptr); /** - * @brief + * @brief Remove the given data node for the given renderer. + * + * @param dataNode The data node that should be removed. + * @param renderer Pointer to the renderer instance for which the data node should be removed. + * If it is a nullptr (default) all controlled renderer will be affected. + * + * @post After a successful call, the "fixedLayer" and "visibility" property will be false and the "layer" property will be deleted. */ void RemoveLayerNode(DataNode* dataNode, const BaseRenderer* renderer = nullptr); - /** - * @brief set the node in the given renderer as the topmost layer (nullptr = all renderer) + * @brief Set the node in the given renderer as the topmost layer. This will change only the "layer" property. * - * @return true, if the node was successfully moved, false otherwise + * @param dataNode The data node that should be moved. + * @param renderer Pointer to the renderer instance for which the data node should be moved. + * If it is a nullptr (default) all controlled renderer will be affected. */ void MoveNodeToFront(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief set the node in the given renderer as the lowermost layer (nullptr = all renderer) + * @brief Set the node in the given renderer as the lowermost layer. This will change only the "layer" property. * - * @return true, if the node was successfully moved, false otherwise + * @param dataNode The data node that should be moved. + * @param renderer Pointer to the renderer instance for which the data node should be moved. + * If it is a nullptr (default) all controlled renderer will be affected. */ void MoveNodeToBack(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief move the node in the given renderer one layer down (nullptr = all renderer) + * @brief Move the node in the given renderer one layer down. This will change only the "layer" property. * - * @return true, if the node was successfully moved, false otherwise + * @param dataNode The data node that should be moved. + * @param renderer Pointer to the renderer instance for which the data node should be moved. + * If it is a nullptr (default) all controlled renderer will be affected. */ void MoveNodeUp(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief move the node in the given renderer one layer up (nullptr = all renderer) + * @brief Move the node in the given renderer one layer up. This will change only the "layer" property. * - * @return true, if the node was successfully moved, false otherwise + * @param dataNode The data node that should be moved. + * @param renderer Pointer to the renderer instance for which the data node should be moved. + * If it is a nullptr (default) all controlled renderer will be affected. */ void MoveNodeDown(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief set the visibility of the given data node for the given renderer (nullptr = all renderer) + * @brief Set the visibility of the given data node for the given renderer. + * + * @param visibility Boolean to set the "visible" property of the given data node. + * @param dataNode The data node that should be moved. + * @param renderer Pointer to the renderer instance for which the data node should be modified. + * If it is a nullptr (default) all controlled renderer will be affected. + * + * @post After a successful call , the "visibility" property will be set to the "visibility" value. */ void SetVisibilityOfDataNode(bool visiblity, DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** - * @brief hide the given data node by setting the 'fixedLayer'property and the 'visible' property of this data node for - * all controlled renderer to false + * @brief Hide the given data node by setting the "visible" property of the data node for + * all controlled renderer to false. + * Later setting the "visible" property of the data node for a certain renderer will overwrite + * the same property of the common renderer. + * + * @param dataNode The data node that should be hid. * - * setting the 'visible' property of a data node for a certain renderer will overwrite the same property of the common renderer + * @post After a successful call , the "visibility" property will be set to the false. */ void HideDataNodeInAllRenderer(const DataNode* dataNode); /** - * @brief reset the given render window (nullptr = all renderer): - * if 'onlyVisibility = true': set all data nodes for the render window to invisible, except for the base node - * if 'onlyVisibility = false': remove all data nodes from the render window, except for the base node + * @brief Reset the given render window: + * If "onlyVisibility = true": set all data nodes for the given render window to invisible, except for the base node. + * If "onlyVisibility = false": remove all data nodes from the render window, except for the base node. + * + * @param visibility Boolean to define the reset mode. + * @param renderer Pointer to the renderer instance for which the data node should be reset. + * If it is a nullptr (default) all controlled renderer will be affected. + * + * @post After a successful call , the "visibility" property will be set to the "false" value (except for the base node). + * If "onlyVisibility = false": additionally the "fixedLayer" property will be false and the "layer" property will be deleted. */ void ResetRenderer(bool onlyVisibility = true, const BaseRenderer* renderer = nullptr); private: void InsertLayerNodeInternal(DataNode* dataNode, int layer, const BaseRenderer* renderer = nullptr); DataStorage::Pointer m_DataStorage; RendererVector m_ControlledRenderer; }; } // namespace mitk #endif // MITKRENDERWINDOWLAYERCONTROLLER_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h index c7c9fe18da..aaa4ab0877 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h +++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h @@ -1,47 +1,59 @@ /*=================================================================== 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 MITKRENDERWINDOWLAYERUTILITIES_H #define MITKRENDERWINDOWLAYERUTILITIES_H -// render window manager +// render window manager module #include "MitkRenderWindowManagerExports.h" -// mitk +// mitk core #include #include /** * @brief Render window layer helper functions to retrieve the currently valid layer stack */ namespace RenderWindowLayerUtilities { typedef std::map> LayerStack; + /** + * The base data node of a renderer is supposed to be on layer 0 (zero), which should be the lowest layer in a render window. + */ + const int BASE_LAYER_INDEX = 0; + /** + * The top layer index, denoting that no valid (positive) layer index is given and therefore the index should be resolved into the topmost layer index. + */ + const int TOP_LAYER_INDEX = -1; /** - * @brief return the stack of layers of the given renderer as std::map, which guarantees ordering of the layers - * stacked layers are only included, if they have set their 'fixedLayer' property to true + * @brief Return the stack of layers of the given renderer as std::map, which guarantees ordering of the layers. + * Stacked layers are only included if they have their "fixedLayer" property set to true and their "layer" property set. + * + * If "renderer" = nullptr: a layer stack won't be created and an empty "LayerStack" will be returned. + * If "withBaseNode" = true: include the base node in the layer stack, if existing. + * If "withBaseNode" = false: exclude the base node from the layer stack. * - * if 'renderer" = nullptr: a layer stack won't be created and an empty 'LayerStack' will be returned - * if 'withBaseNode' = true: include the base node (layer = 0) in the layer stack, if existing - * if 'withBaseNode' = false: exclude the base node (layer = 0) from the layer stack + * @param dataStorage Pointer to a data storage instance whose data nodes should be checked and possibly be included. + * @param renderer Pointer to the renderer instance for which the layer stack should be generated. + * @param withBaseNode Boolean to decide whether the base node should be included in or excluded from the layer stack. */ MITKRENDERWINDOWMANAGER_EXPORT LayerStack GetLayerStack(const mitk::DataStorage* dataStorage, const mitk::BaseRenderer* renderer, bool withBaseNode); } // namespace RenderWindowLayerUtilities #endif // MITKRENDERWINDOWLAYERUTILITIES_H diff --git a/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp b/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp index f40cf5bc5d..c98840bdb6 100644 --- a/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp +++ b/Modules/RenderWindowManager/src/QmitkRenderWindowDataModel.cpp @@ -1,204 +1,204 @@ /*=================================================================== 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 "QmitkRenderWindowDataModel.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()) { bool visibility = false; dataNode->GetVisibility(visibility, m_BaseRenderer); if (visibility) { return Qt::Checked; } else { return Qt::Unchecked; } } else if (Qt::DisplayRole == role && 1 == index.column()) { return QVariant(QString::fromStdString(dataNode->GetName())); } else if (Qt::ToolTipRole == role) { if (0 == index.column()) { return QVariant("Show/hide data node."); } else if (1 == index.column()) { return QVariant("Name of the data node."); } } else if (Qt::UserRole == role) { // user role always returns the data node name, as the name is needed to manipulate a data node return QVariant(QString::fromStdString(dataNode->GetName())); } } 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 (1 == section) + 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/RenderWindowManager/src/mitkRenderWindowLayerController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp index 2b22623526..a0d365099c 100644 --- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp +++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp @@ -1,548 +1,497 @@ /*=================================================================== 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 module #include "mitkRenderWindowLayerController.h" -#include "mitkRenderWindowLayerUtilities.h" -// mitk +// mitk core #include "mitkRenderingManager.h" mitk::RenderWindowLayerController::RenderWindowLayerController() : m_DataStorage(nullptr) { SetControlledRenderer(RenderingManager::GetInstance()->GetAllRegisteredRenderWindows()); } -mitk::RenderWindowLayerController::~RenderWindowLayerController() -{ - if (m_DataStorage.IsNull()) - { - return; - } - - // delete renderer properties for all data nodes - for (const auto& renderer : m_ControlledRenderer) - { - if (renderer.IsNotNull()) - { - // get all nodes connected with the renderer - RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); - for (auto& layer : stackedLayers) - { - layer.second->GetPropertyList(renderer)->DeleteProperty("layer"); - layer.second->GetPropertyList(renderer)->DeleteProperty("fixedLayer"); - layer.second->GetPropertyList(renderer)->DeleteProperty("visible"); - layer.second->Modified(); - - // alternatively - but this will remove all renderer specific properties (not only the three above) - //layer.second->GetPropertyList(renderer)->Clear(); - } - } - } -} - void mitk::RenderWindowLayerController::SetDataStorage(DataStorage::Pointer dataStorage) { if (m_DataStorage != dataStorage) { // set the new data storage m_DataStorage = dataStorage; } } void mitk::RenderWindowLayerController::SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows) { BaseRenderer* baseRenderer = nullptr; for (const auto &renderWindow : renderWindows) { baseRenderer = BaseRenderer::GetInstance(renderWindow); if (nullptr != baseRenderer) { m_ControlledRenderer.push_back(baseRenderer); } } } void mitk::RenderWindowLayerController::SetControlledRenderer(RendererVector controlledRenderer) { if (m_ControlledRenderer != controlledRenderer) { // set the new set of controlled renderer m_ControlledRenderer = controlledRenderer; } } void mitk::RenderWindowLayerController::SetBaseDataNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // set the data node as base data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { SetBaseDataNode(dataNode, renderer); } } } else { // get the layer stack with the base data node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); if (!stackedLayers.empty()) { // see if base layer exists - RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(0); + RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(RenderWindowLayerUtilities::BASE_LAYER_INDEX); if (layerStackIterator != stackedLayers.end()) { // remove the current base data node from the current renderer layerStackIterator->second->GetPropertyList(renderer)->DeleteProperty("layer"); layerStackIterator->second->SetBoolProperty("fixedLayer", false, renderer); layerStackIterator->second->SetVisibility(false, renderer); } } - // 0 indicates the base data node --> set as new background - dataNode->SetIntProperty("layer", 0, renderer); + // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background + dataNode->SetIntProperty("layer", RenderWindowLayerUtilities::BASE_LAYER_INDEX, renderer); dataNode->SetBoolProperty("fixedLayer", true, renderer); dataNode->SetVisibility(true, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } -void mitk::RenderWindowLayerController::InsertLayerNode(DataNode* dataNode, int layer /*= -1*/, const BaseRenderer* renderer /*= nullptr*/) +void mitk::RenderWindowLayerController::InsertLayerNode(DataNode* dataNode, int layer /*= RenderWindowLayerUtilities::TOP_LAYER_INDEX*/, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // insert data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { InsertLayerNode(dataNode, layer, renderer); } } } else { - if (0 == layer) + if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layer) { - // 0 indicates the base data node --> set as new background (overwrite current base node if needed) + // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background (overwrite current base node if needed) SetBaseDataNode(dataNode, renderer); } else { InsertLayerNodeInternal(dataNode, layer, renderer); } } } void mitk::RenderWindowLayerController::InsertLayerNodeInternal(DataNode* dataNode, int newLayer, const BaseRenderer* renderer /*= nullptr*/) { dataNode->SetBoolProperty("fixedLayer", true, renderer); dataNode->SetVisibility(true, renderer); // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (stackedLayers.empty()) { // no layer stack for the current renderer - if (-1 == newLayer) + if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer) { // set given layer as first layer above base layer (= 1) newLayer = 1; // alternatively: no layer stack for the current renderer -> insert as background node //SetBaseDataNode(dataNode, renderer); } } else { - if (-1 == newLayer) + if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer) { // get the first value (highest int-key -> topmost layer) // +1 indicates inserting the node above the topmost layer newLayer = stackedLayers.begin()->first + 1; } else { // see if layer is already taken RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(newLayer); for (; layerStackIterator != stackedLayers.end(); ++layerStackIterator) { // move data nodes after the new layer one layer up layerStackIterator->second->SetIntProperty("layer", layerStackIterator->first + 1, renderer); } } } // update data storage (the "data node model") dataNode->SetIntProperty("layer", newLayer, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } void mitk::RenderWindowLayerController::RemoveLayerNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // remove data node from all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { RemoveLayerNode(dataNode, renderer); } } } else { - // get the layer stack with the base node of the current renderer - RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); - int layer = -1; - dataNode->GetIntProperty("layer", layer, renderer); - // get an index from iterator - int row = std::distance(stackedLayers.begin(), stackedLayers.find(layer)); - // "remove" node from the renderer list dataNode->GetPropertyList(renderer)->DeleteProperty("layer"); dataNode->SetBoolProperty("fixedLayer", false, renderer); dataNode->SetVisibility(false, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } void mitk::RenderWindowLayerController::MoveNodeToFront(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node to front in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeToFront(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the first value (highest int-key -> topmost layer) int topmostLayer = stackedLayers.begin()->first; // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound && currentLayer < topmostLayer) { - // move the current data node to the current topmost layer - dataNode->SetIntProperty("layer", topmostLayer, renderer); - - for (auto& layer : stackedLayers) - { - if (layer.second != dataNode && layer.first > currentLayer) - { - // move all other data nodes one layer down, if their layer was above the layer of the current node - layer.second->SetIntProperty("layer", layer.first - 1, renderer); - // alternatively: stack all layers below the topmost layer - // this would fill gaps between the layers of the renderer, every time a node is moved to front - // TODO: reverse iteration needed! layer.second->SetIntProperty("layer", --topmostLayer, renderer); - } - // else: current data node has already been moved to the topmost layer - } + // move the current data node above the current topmost layer + dataNode->SetIntProperty("layer", topmostLayer+1, renderer); } // else: data node has no layer information or is already the topmost layer node } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeToBack(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node to back in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeToBack(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the last value (lowest int-key) - // cannot be the layer 0 (base node) as the base node was excluded by the 'GetLayerStack'-function + // cannot be the base layer as the base node was excluded by the 'GetLayerStack'-function int lowermostLayer = stackedLayers.rbegin()->first; // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound && currentLayer > lowermostLayer) { // move the current data node to the current lowermost layer dataNode->SetIntProperty("layer", lowermostLayer, renderer); // move all other data nodes one layer up for (auto& layer : stackedLayers) { - if (layer.second != dataNode) + if (layer.second != dataNode && layer.first < currentLayer) { layer.second->SetIntProperty("layer", layer.first + 1, renderer); - // alternatively: stack all layers on top of the lowermost layer - // this would fill gaps between the layers of the renderer, every time a node is moved to back - //layer.second->SetIntProperty("layer", ++lowermostLayer, renderer); } // else: current data node has already been moved to the lowermost layer } } // else: data node has no layer information or is already the lowermost layer node } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeUp(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node down in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeUp(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound) { // get the current layer in the map of stacked layers RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer); if (layerStackIterator != stackedLayers.end() && layerStackIterator != stackedLayers.begin()) { // found the element in the map, at different position than 'begin' -> // current node is not on the topmost layer and therefore can be moved one layer up // swap the layers of the dataNode and the dataNode on the next higher layer (previous map element) RenderWindowLayerUtilities::LayerStack::const_iterator prevLayerStackIterator = std::prev(layerStackIterator); dataNode->SetIntProperty("layer", prevLayerStackIterator->first, renderer); prevLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer); //prevLayerStackIterator->second->Modified(); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } // else: layer stack does not contain a layer with the 'currentLayer'data node or // layer is already the topmost layer node } // else: data node has no layer information } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeDown(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node up in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeDown(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound) { // get the current layer in the map of stacked layers RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer); if (layerStackIterator != stackedLayers.end()) { // found the element in the map ... RenderWindowLayerUtilities::LayerStack::const_iterator nextLayerStackIterator = std::next(layerStackIterator); if (nextLayerStackIterator != stackedLayers.end()) { // ... and found a successor -> // current node is not on the lowermost layer and therefore can be moved one layer down // swap the layers of the dataNode and the dataNode on the next lower layer (next map element) dataNode->SetIntProperty("layer", nextLayerStackIterator->first, renderer); nextLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer); //nextLayerStackIterator->second->Modified(); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } // else: data node is already the lowermost layer node } // else: layer stack does not contain a layer with the 'currentLayer' } // else: data node has no layer information } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::SetVisibilityOfDataNode(bool visibility, DataNode* dataNode, const BaseRenderer* renderer /*=nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // set visibility of data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { - dataNode->SetVisibility(visibility, renderer); - dataNode->Modified(); - mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); + SetVisibilityOfDataNode(visibility, dataNode, renderer); } } } else { dataNode->SetVisibility(visibility, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } void mitk::RenderWindowLayerController::HideDataNodeInAllRenderer(const DataNode* dataNode) { + if (nullptr == dataNode) + { + return; + } + for (const auto& renderer : m_ControlledRenderer) { - if (nullptr != dataNode && renderer.IsNotNull()) + if (renderer.IsNotNull()) { dataNode->GetPropertyList(renderer)->SetBoolProperty("visible", false); } } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void mitk::RenderWindowLayerController::ResetRenderer(bool onlyVisibility /*= true*/, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == renderer) { // reset all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { ResetRenderer(onlyVisibility, renderer); } } } else { // get the layer stack with the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); if (!stackedLayers.empty()) { for (const auto& layer : stackedLayers) { int layerLevel; layer.second->GetIntProperty("layer", layerLevel, renderer); - if (0 == layerLevel) + if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layerLevel) { - // set base data node visibility to true (layer = 0) + // set base data node visibility to true layer.second->SetVisibility(true, renderer); } else { + // set visibility of all other data nodes to false + layer.second->SetVisibility(false, renderer); + // modify layer node - if (onlyVisibility) - { - // set layer node visibility to false - layer.second->SetVisibility(false, renderer); - } - else + if (!onlyVisibility) { - // remove layer node from current renderer + // clear mode: additionally remove layer node from current renderer layer.second->GetPropertyList(renderer)->DeleteProperty("layer"); layer.second->SetBoolProperty("fixedLayer", false, renderer); - layer.second->SetVisibility(false, renderer); } } layer.second->Modified(); } mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } } diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp index 253113cc08..29ac67fbd1 100644 --- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp +++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp @@ -1,62 +1,63 @@ /*=================================================================== 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 module #include "mitkRenderWindowLayerUtilities.h" -// mitk +// mitk core #include #include #include RenderWindowLayerUtilities::LayerStack RenderWindowLayerUtilities::GetLayerStack(const mitk::DataStorage* dataStorage, const mitk::BaseRenderer* renderer, bool withBaseNode) { LayerStack stackedLayers; if (nullptr == dataStorage || nullptr == renderer) { // no nodes to stack or no renderer selected return stackedLayers; } int layer = -1; mitk::NodePredicateProperty::Pointer helperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)); mitk::NodePredicateNot::Pointer notAHelperObject = mitk::NodePredicateNot::New(helperObject); mitk::NodePredicateProperty::Pointer fixedLayer = mitk::NodePredicateProperty::New("fixedLayer", mitk::BoolProperty::New(true), renderer); // combine node predicates mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::NodePredicateAnd::New(notAHelperObject, fixedLayer); mitk::DataStorage::SetOfObjects::ConstPointer filteredDataNodes = dataStorage->GetSubset(combinedNodePredicate); for (mitk::DataStorage::SetOfObjects::ConstIterator it = filteredDataNodes->Begin(); it != filteredDataNodes->End(); ++it) { mitk::DataNode::Pointer dataNode = it->Value(); if (dataNode.IsNull()) { continue; } bool layerFound = dataNode->GetIntProperty("layer", layer, renderer); if (layerFound) { - if (layer != 0 || withBaseNode) + if (BASE_LAYER_INDEX != layer|| withBaseNode) { // data node is not on the base layer or the base layer should be included anyway stackedLayers.insert(std::make_pair(layer, dataNode)); } } } return stackedLayers; } 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 54bb939604..034fd85768 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp @@ -1,218 +1,220 @@ /*=================================================================== 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 +// mitk core #include // qt #include #include #include const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager"; void QmitkRenderWindowManagerView::SetFocus() { m_Controls.radioButtonAxial->setFocus(); } void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent) { // create GUI widgets from the Qt Designer's .ui file m_Parent = parent; m_Controls.setupUi(m_Parent); // 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(GetDataStorage()); m_RenderWindowViewDirectionController->SetDataStorage(GetDataStorage()); mitk::RenderWindowLayerController::RendererVector controlledRenderer = m_RenderWindowLayerController->GetControlledRenderer(); for (const auto& renderer : controlledRenderer) { m_Controls.comboBoxRenderWindowSelection->addItem(renderer->GetName()); } // create a new model m_RenderWindowDataModel = std::make_unique(this); m_RenderWindowDataModel->SetDataStorage(GetDataStorage()); m_RenderWindowDataModel->SetCurrentRenderer(m_Controls.comboBoxRenderWindowSelection->itemText(0).toStdString()); 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); //m_VisibilityDelegate = new QmitkVisibilityDelegate(this); //m_Controls.renderWindowTableView->setItemDelegateForColumn(0, m_VisibilityDelegate); m_AddLayerWidget = new QmitkLayerManagerAddLayerWidget(m_Parent); m_AddLayerWidget->hide(); m_AddLayerWidget->SetDataStorage(GetDataStorage()); SetUpConnections(); } void QmitkRenderWindowManagerView::SetUpConnections(void) { connect(m_Controls.comboBoxRenderWindowSelection, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(OnRenderWindowSelectionChanged(const QString&))); connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SLOT(ShowAddLayerWidget())); 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())); connect(m_AddLayerWidget, SIGNAL(LayerToAddSelected(mitk::DataNode*)), this, SLOT(AddLayer(mitk::DataNode*))); } void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId) { std::string currentRendererName = renderWindowId.toStdString(); m_RenderWindowDataModel->SetCurrentRenderer(currentRendererName); mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(currentRendererName); 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 QmitkRenderWindowManagerView::ShowAddLayerWidget() { m_AddLayerWidget->ListLayer(); m_AddLayerWidget->show(); } void QmitkRenderWindowManagerView::AddLayer(mitk::DataNode* dataNode) { const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, selectedRenderer); } void QmitkRenderWindowManagerView::RemoveLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowLayerController->RemoveLayerNode(dataNode, selectedRenderer); m_Controls.renderWindowTableView->clearSelection(); } } void QmitkRenderWindowManagerView::SetAsBaseLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowLayerController->SetBaseDataNode(dataNode, selectedRenderer); m_Controls.renderWindowTableView->clearSelection(); } } void QmitkRenderWindowManagerView::MoveLayer(const QString &direction) { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); if ("up" == direction) { m_RenderWindowLayerController->MoveNodeUp(dataNode, selectedRenderer); } else { m_RenderWindowLayerController->MoveNodeDown(dataNode, selectedRenderer); } m_Controls.renderWindowTableView->clearSelection(); } } void QmitkRenderWindowManagerView::ResetRenderer() { const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowLayerController->ResetRenderer(true, selectedRenderer); m_Controls.renderWindowTableView->clearSelection(); } void QmitkRenderWindowManagerView::ClearRenderer() { const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowLayerController->ResetRenderer(false, selectedRenderer); m_Controls.renderWindowTableView->clearSelection(); } void QmitkRenderWindowManagerView::ChangeViewDirection(const QString &viewDirection) { mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), selectedRenderer); } void QmitkRenderWindowManagerView::NodeAdded(const mitk::DataNode* node) { // 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 in the node list of a render window m_RenderWindowLayerController->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 cd069680f4..e5eb6d0aaa 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h @@ -1,92 +1,92 @@ /*=================================================================== 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" #include "QmitkLayerManagerAddLayerWidget.h" + // render window manager module #include #include #include -#include "QmitkVisibilityDelegate.h" +//#include // blueberry #include // qt #include #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; void SetUpConnections(); private Q_SLOTS: /** * @brief called when the user changes the render window selection in the combo box */ void OnRenderWindowSelectionChanged(const QString &renderWindowId); void ShowAddLayerWidget(); void AddLayer(mitk::DataNode* dataNode); void RemoveLayer(); void SetAsBaseLayer(); void MoveLayer(const QString &direction); void ResetRenderer(); void ClearRenderer(); void ChangeViewDirection(const QString &viewDirection); private: /** * @brief set each 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; std::unique_ptr m_RenderWindowDataModel; std::unique_ptr m_RenderWindowLayerController; std::unique_ptr m_RenderWindowViewDirectionController; QmitkLayerManagerAddLayerWidget* m_AddLayerWidget; }; #endif // QMITKRENDERWINDOWMANAGERVIEW_H