.. _program_listing_file_MRML_vtkMRMLLayerDMWidgetEventTranslationNode.h:

Program Listing for File vtkMRMLLayerDMWidgetEventTranslationNode.h
===================================================================

|exhale_lsh| :ref:`Return to documentation for file <file_MRML_vtkMRMLLayerDMWidgetEventTranslationNode.h>` (``MRML/vtkMRMLLayerDMWidgetEventTranslationNode.h``)

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

.. code-block:: cpp

   #pragma once
   
   #include "vtkSlicerLayerDMModuleMRMLExport.h"
   
   // Slicer includes
   #include <vtkMRMLNode.h>
   #include <vtkMRMLAbstractWidget.h>
   
   // VTK includes
   #include <vtkCommand.h>
   #include <vtkEvent.h>
   
   // STL includes
   #include <map>
   
   class vtkMRMLInteractionEventData;
   
   class VTK_SLICER_LAYERDM_MODULE_MRML_EXPORT vtkMRMLLayerDMWidgetEventTranslationNode : public vtkMRMLNode
   {
   public:
     static vtkMRMLLayerDMWidgetEventTranslationNode* New();
     vtkTypeMacro(vtkMRMLLayerDMWidgetEventTranslationNode, vtkMRMLNode);
   
     vtkMRMLLayerDMWidgetEventTranslationNode(const vtkMRMLLayerDMWidgetEventTranslationNode&) = delete;
     void operator=(const vtkMRMLLayerDMWidgetEventTranslationNode&) = delete;
   
     void PrintSelf(ostream& os, vtkIndent indent) override;
     void Copy(vtkMRMLNode* node) override;
     void ReadXMLAttributes(const char** atts) override;
     void WriteXML(ostream& of, int indent) override;
   
     vtkMRMLNode* CreateNodeInstance() override;
     const char* GetNodeTagName() override;
   
     static unsigned long GetEndInteractionEvent(unsigned long startInteractionEvent);
   
     static unsigned long GetClickEvent(unsigned long releaseEvent);
   
     void SetTranslation(int widgetState, unsigned long interactionEvent, unsigned long widgetEvent, int modifier = vtkEvent::NoModifier);
   
     void SetTranslationClickAndDrag(int widgetState,
                                     unsigned long interactionEvent,
                                     int widgetStateDragging,
                                     unsigned long widgetStartEvent,
                                     unsigned long widgetEndEvent,
                                     int modifiers = vtkEvent::NoModifier);
   
     void SetTranslationKeyboard(int widgetState,
                                 const std::string& keySym,
                                 unsigned long widgetEvent,
                                 int modifier = vtkEvent::NoModifier,
                                 int repeatCount = 1,
                                 unsigned long keyEvent = vtkCommand::KeyPressEvent);
   
     int RemoveTranslationEvent(unsigned long widgetEvent);
   
     bool BlockTranslationEvent(unsigned long widgetEvent, bool isBlocked);
   
     bool BlockAllTranslationEvents(bool isBlocked);
   
     unsigned long Translate(int widgetState, vtkMRMLInteractionEventData* eventData);
   
     void Clear();
   
     int GetNumberOfTranslations() const;
   
   protected:
     vtkMRMLLayerDMWidgetEventTranslationNode() = default;
     ~vtkMRMLLayerDMWidgetEventTranslationNode() override = default;
   
   private:
     struct EventKey
     {
       bool operator==(const EventKey& other) const { return this->AsTuple() == other.AsTuple(); }
       bool operator<(const EventKey& other) const { return this->AsTuple() < other.AsTuple(); }
       std::tuple<int, unsigned long, int, int, std::string> AsTuple() const { return std::make_tuple(widgetState, eventId, modifier, repeatCount, keySym); }
   
       static int thresholdRepeatCount(int repeatCount) { return std::max(1, repeatCount); }
   
       int widgetState{ vtkMRMLAbstractWidget::WidgetStateAny };
       unsigned long eventId{ vtkCommand::NoEvent };
       int modifier{ vtkEvent::NoModifier };
       int repeatCount{ 1 };
       std::string keySym{};
     };
   
     void SetTranslation(const EventKey& key, unsigned long widgetEvent);
     unsigned long Translate(EventKey key) const;
     bool IsWidgetEventBlocked(unsigned long widgetEvent) const;
     unsigned long GetWidgetEvent(const EventKey& key) const;
   
     static std::string ToString(const std::map<EventKey, unsigned long>& eventMap, const vtkIndent* indent, const std::string& eol);
     static std::string ToString(const std::pair<EventKey, unsigned long>& eventPair);
   
     static std::map<EventKey, unsigned long> EventMapFromString(const std::string& value);
     static std::pair<EventKey, unsigned long> EventPairFromString(const std::string& value);
   
     std::map<EventKey, unsigned long> EventMap{};
     std::set<unsigned long> BlockedEvents{};
     bool IsBlocked{};
   };