vtkMRMLLayerDMWidgetEventTranslationNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware SAS
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Thibault Pelletier, Kitware SAS,
  and was partially funded by ANR grants ANR-22-CE45-0034 and ANR-18-RHUS-005.
 
==============================================================================*/
 
#ifndef __vtkMRMLLayerDMWidgetEventTranslationNode_h
#define __vtkMRMLLayerDMWidgetEventTranslationNode_h
 
#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;

  vtkMRMLCopyContentMacro(vtkMRMLLayerDMWidgetEventTranslationNode);
 
  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(this->WidgetState, this->EventId, this->Modifier, this->RepeatCount, this->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{};
};
 
#endif