.. _program_listing_file_Logic_vtkSlicerLayerDMLogic.h:

Program Listing for File vtkSlicerLayerDMLogic.h
================================================

|exhale_lsh| :ref:`Return to documentation for file <file_Logic_vtkSlicerLayerDMLogic.h>` (``Logic/vtkSlicerLayerDMLogic.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include "vtkSlicerLayerDMModuleLogicExport.h"
   
   // Slicer includes
   #include <vtkMRMLDisplayableNode.h>
   #include <vtkMRMLScene.h>
   #include <vtkSlicerModuleLogic.h>
   
   class vtkMRMLLayerDMWidgetEventTranslationNode;
   
   class VTK_SLICER_LAYERDM_MODULE_LOGIC_EXPORT vtkSlicerLayerDMLogic : public vtkSlicerModuleLogic
   {
   public:
     static vtkSlicerLayerDMLogic* New();
     vtkTypeMacro(vtkSlicerLayerDMLogic, vtkSlicerModuleLogic);
   
     vtkSlicerLayerDMLogic(const vtkSlicerLayerDMLogic&) = delete;
     void operator=(const vtkSlicerLayerDMLogic&) = delete;
   
     void RegisterNodes() override;
   
     static int GetVersionMajor();
     static int GetVersionMinor();
     static int GetVersionPatch();
     static std::string GetVersion();
   
     static void SetWidgetEventTranslationNode(vtkMRMLNode* node, vtkMRMLLayerDMWidgetEventTranslationNode* translationNode);
   
     static vtkMRMLLayerDMWidgetEventTranslationNode* GetWidgetEventTranslationNode(vtkMRMLNode* node);
   
     static vtkMRMLLayerDMWidgetEventTranslationNode* GetWidgetEventTranslationSingleton(vtkMRMLScene* scene, const std::string& singletonId);
   
     static vtkMRMLLayerDMWidgetEventTranslationNode* GetWidgetEventTranslationSingleton(vtkMRMLScene* scene,
                                                                                         const std::string& singletonId,
                                                                                         const std::function<void(vtkMRMLLayerDMWidgetEventTranslationNode*)>& configureF);
   
     static vtkMRMLLayerDMWidgetEventTranslationNode* CreateWidgetEventTranslationSingleton(vtkMRMLScene* scene, const std::string& singletonId);
   
     static void CreateDefaultEventTranslation(vtkMRMLNode* node, const std::string& singletonId, const std::function<void(vtkMRMLLayerDMWidgetEventTranslationNode*)>& configureF);
   
     static std::string GetEventTranslationRole();
   
     static std::string GetDisplayRole();
   
     template <typename T>
     static void RegisterNodeIfNeeded(vtkMRMLScene* scene);
   
     template <typename T>
     static T* GetDisplayNode(vtkMRMLNode* node);
   
     template <typename T>
     static T* GetReferenceNode(vtkMRMLNode* node, const char* role);
   
     template <typename T>
     static T* GetReferenceNode(vtkMRMLNode* node);
   
     template <typename T>
     static std::vector<T*> GetReferenceNodes(vtkMRMLNode* node, const char* role);
   
     template <typename T>
     static std::vector<T*> GetReferenceNodes(vtkMRMLNode* node);
   
     template <typename T>
     static T* CreateDisplayNode(vtkMRMLNode* node, bool allowMultiple = false);
   
     template <typename T>
     static T* CreateReferenceNode(vtkMRMLNode* node, const char* role, bool allowMultiple = false);
   
     template <typename T>
     static T* CreateReferenceNode(vtkMRMLNode* node, bool allowMultiple = false);
   
     template <typename T>
     static T* AddReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role);
   
     template <typename T>
     static T* SetReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role);
   
     template <typename T>
     static T* SetNthReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role, int nthRef);
   
   protected:
     vtkSlicerLayerDMLogic() = default;
     ~vtkSlicerLayerDMLogic() override = default;
   
   private:
     template <typename T>
     static T* ModifyNodeReference(vtkMRMLNode* node, vtkMRMLNode* nodeRef, const std::function<void()>& modifyF)
     {
       if (!node || !nodeRef)
       {
         return nullptr;
       }
   
       modifyF();
       return T::SafeDownCast(nodeRef);
     }
   
     static constexpr auto EventTranslationRole{ "widgetEventTranslation" };
     static constexpr auto DisplayRole{ "display" }; // copied from vtkMRMLDisplayableNode
   };
   
   //----------------------------------------------------------------------------
   template <typename T>
   void vtkSlicerLayerDMLogic::RegisterNodeIfNeeded(vtkMRMLScene* scene)
   {
     if (!scene)
     {
       return;
     }
   
     vtkNew<T> node;
     if (!scene->IsNodeClassRegistered(node.Get()->GetClassName()))
     {
       scene->RegisterNodeClass(node.Get());
     }
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::GetDisplayNode(vtkMRMLNode* node)
   {
     if (!node)
     {
       return {};
     }
   
     return GetReferenceNode<T>(node, DisplayRole);
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::GetReferenceNode(vtkMRMLNode* node, const char* role)
   {
     const auto referenceNodes = GetReferenceNodes<T>(node, role);
     return referenceNodes.empty() ? nullptr : referenceNodes[0];
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::GetReferenceNode(vtkMRMLNode* node)
   {
     return GetReferenceNode<T>(node, T::GetReferenceRole());
   }
   
   template <typename T>
   std::vector<T*> vtkSlicerLayerDMLogic::GetReferenceNodes(vtkMRMLNode* node, const char* role)
   {
     if (!node)
     {
       return {};
     }
   
     std::vector<T*> referenceNodes;
     for (int i_node = 0; i_node < node->GetNumberOfNodeReferences(role); i_node++)
     {
       if (auto refNode = T::SafeDownCast(node->GetNthNodeReference(role, i_node)))
       {
         referenceNodes.emplace_back(refNode);
       }
     }
     return referenceNodes;
   }
   
   template <typename T>
   std::vector<T*> vtkSlicerLayerDMLogic::GetReferenceNodes(vtkMRMLNode* node)
   {
     return GetReferenceNodes<T>(node, T::GetReferenceRole());
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::CreateDisplayNode(vtkMRMLNode* node, bool allowMultiple)
   {
     if (!node)
     {
       return {};
     }
   
     return CreateReferenceNode<T>(node, DisplayRole, allowMultiple);
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::CreateReferenceNode(vtkMRMLNode* node, const char* role, bool allowMultiple)
   {
     auto scene = node ? node->GetScene() : nullptr;
     if (!node || !scene)
     {
       return {};
     }
   
     auto nodeRef = GetReferenceNode<T>(node, role);
     if (nodeRef && !allowMultiple)
     {
       return nodeRef;
     }
   
     nodeRef = T::SafeDownCast(scene->AddNewNodeByClass(vtkSmartPointer<T>::New()->GetClassName()));
     return AddReferenceNode<T>(node, nodeRef, role);
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::CreateReferenceNode(vtkMRMLNode* node, bool allowMultiple)
   {
     return CreateReferenceNode<T>(node, T::GetReferenceRole(), allowMultiple);
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::AddReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role)
   {
     return ModifyNodeReference<T>(node, nodeRef, [=] { node->AddAndObserveNodeReferenceID(role, nodeRef->GetID()); });
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::SetReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role)
   {
     return ModifyNodeReference<T>(node, nodeRef, [=] { node->SetAndObserveNodeReferenceID(role, nodeRef->GetID()); });
   }
   
   template <typename T>
   T* vtkSlicerLayerDMLogic::SetNthReferenceNode(vtkMRMLNode* node, T* nodeRef, const char* role, int nthRef)
   {
     return ModifyNodeReference<T>(node, nodeRef, [=] { node->SetAndObserveNthNodeReferenceID(role, nthRef, nodeRef->GetID()); });
   }