vtkMRMLAbstractDisplayableManager.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  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 Jean-Christophe Fillion-Robin, Kitware Inc.
  and was partially funded by NIH grant 3P41RR013218-12S1
 
==============================================================================*/
 
#ifndef __vtkMRMLAbstractDisplayableManager_h
#define __vtkMRMLAbstractDisplayableManager_h
 
// MRMLLogic includes
#include "vtkMRMLAbstractLogic.h"
 
#include "vtkMRMLDisplayableManagerExport.h"
 
class vtkMRMLInteractionEventData;
class vtkMRMLInteractionNode;
class vtkMRMLSelectionNode;
class vtkMRMLDisplayableManagerGroup;
class vtkMRMLNode;
class vtkMRMLScene;
class vtkMRMLLightBoxRendererManagerProxy;
 
class vtkRenderer;
class vtkRenderWindowInteractor;
 
class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLAbstractDisplayableManager
  : public vtkMRMLAbstractLogic
{
public:
  static vtkMRMLAbstractDisplayableManager *New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkTypeMacro(vtkMRMLAbstractDisplayableManager, vtkMRMLAbstractLogic);
 
  bool IsCreated();
 
  virtual void SetLightBoxRendererManagerProxy(vtkMRMLLightBoxRendererManagerProxy *);
 
  virtual vtkMRMLLightBoxRendererManagerProxy* GetLightBoxRendererManagerProxy();
 
  vtkRenderer* GetRenderer();
 
  vtkRenderer* GetRenderer(int idx);
 
  vtkRenderWindowInteractor* GetInteractor();
 
  vtkMRMLInteractionNode* GetInteractionNode();
 
  vtkMRMLSelectionNode* GetSelectionNode();
 
  virtual std::string GetDataProbeInfoStringForPosition(
      double vtkNotUsed(xyz)[3]) { return ""; }
 
  virtual bool CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double &distance2);
 
  virtual bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData);
 
  virtual void SetHasFocus(bool hasFocus, vtkMRMLInteractionEventData* eventData);
 
  virtual bool GetGrabFocus();
 
  virtual bool GetInteractive();
 
  virtual int GetMouseCursor();
 
  void SetMouseCursor(int cursor);
 
protected:
 
  vtkMRMLAbstractDisplayableManager();
  ~vtkMRMLAbstractDisplayableManager() override;
 
  vtkMRMLNode * GetMRMLDisplayableNode();
 
  friend class vtkMRMLDisplayableManagerGroup;
 
  virtual void SetMRMLDisplayableManagerGroup(vtkMRMLDisplayableManagerGroup* group);
  virtual void SetRenderer(vtkRenderer* newRenderer);
 
  virtual void AdditionalInitializeStep(){}
 
  virtual int ActiveInteractionModes();
 
  void ProcessMRMLNodesEvents(vtkObject* caller,
                                      unsigned long event,
                                      void * callData) override;
 
  virtual void ProcessWidgetsEvents(vtkObject* caller,
                                    unsigned long event,
                                    void * callData);
 
  static void WidgetsCallback(vtkObject *caller, unsigned long eid,
                              void *clientData, void *callData);
 
  vtkCallbackCommand * GetWidgetsCallbackCommand();
 
  vtkObserverManager * GetWidgetsObserverManager()const;
 
  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;
 
  virtual void OnMRMLDisplayableNodeModifiedEvent(vtkObject* caller);
 
  void AddMRMLDisplayableManagerEvent(int eventId);
 
  void SetAndObserveMRMLDisplayableNode(vtkMRMLNode * newMRMLDisplayableNode);
 
  vtkMRMLDisplayableManagerGroup * GetMRMLDisplayableManagerGroup();
 
  void CreateIfPossible();
 
  virtual void Create();
 
  virtual void RemoveMRMLObservers();
 
  void SetUpdateFromMRMLRequested(bool requested);
 
  virtual void UpdateFromMRML(){}
 
  void RequestRender();
 
  void AddInteractorStyleObservableEvent(int eventid, float priority=0.0);
 
  void RemoveInteractorStyleObservableEvent(int eventid);
 
  void AddInteractorObservableEvent(int eventid, float priority=0.0);
 
  void RemoveInteractorObservableEvent(int eventid);
 
  virtual void OnInteractorStyleEvent(int eventid);
 
  virtual void OnInteractorEvent(int eventid);
 
  void SetInteractorStyleAbortFlag(int f);
  int GetInteractorStyleAbortFlag();
  void InteractorStyleAbortFlagOn();
  void InteractorStyleAbortFlagOff();
 
  void SetInteractorAbortFlag(int f);
  int GetInteractorAbortFlag();
  void InteractorAbortFlagOn();
  void InteractorAbortFlagOff();
 
private:
 
  vtkMRMLAbstractDisplayableManager(const vtkMRMLAbstractDisplayableManager&) = delete;
  void operator=(const vtkMRMLAbstractDisplayableManager&) = delete;
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal; // For access from the callback function
};
 
#endif