vtkInteractorObserver.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkInteractorObserver_h
#define vtkInteractorObserver_h
 
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractPropPicker;
class vtkAssemblyPath;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkCallbackCommand;
class vtkObserverMediator;
class vtkPickingManager;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkInteractorObserver : public vtkObject
{
public:
  vtkTypeMacro(vtkInteractorObserver, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  VTK_MARSHALEXCLUDE(
    "is overridden by vtkInteractorStyle::Enabled in the correct order after Interactor")
  virtual void SetEnabled(int) {}
  VTK_MARSHALEXCLUDE(
    "is overridden by vtkInteractorStyle::Enabled in the correct order after Interactor")
  int GetEnabled() { return this->Enabled; }
  void EnabledOn() { this->SetEnabled(1); }
  void EnabledOff() { this->SetEnabled(0); }
  void On() { this->SetEnabled(1); }
  void Off() { this->SetEnabled(0); }
 
 
  VTK_MARSHALEXCLUDE(
    "is overridden by vtkInteractorStyle::Interactor in the correct order before Enabled")
  virtual void SetInteractor(vtkRenderWindowInteractor* iren);
  VTK_MARSHALEXCLUDE(
    "is overridden by vtkInteractorStyle::Interactor in the correct order before Enabled")
  vtkGetObjectMacro(Interactor, vtkRenderWindowInteractor);
 
 
  vtkSetClampMacro(Priority, float, 0.0f, 1.0f);
  vtkGetMacro(Priority, float);
 
 
  vtkBooleanMacro(PickingManaged, bool);
  virtual void SetPickingManaged(bool managed);
  vtkGetMacro(PickingManaged, bool);
 
 
  vtkSetMacro(KeyPressActivation, vtkTypeBool);
  vtkGetMacro(KeyPressActivation, vtkTypeBool);
  vtkBooleanMacro(KeyPressActivation, vtkTypeBool);
 
 
  vtkSetMacro(KeyPressActivationValue, char);
  vtkGetMacro(KeyPressActivationValue, char);
 
 
  vtkGetObjectMacro(DefaultRenderer, vtkRenderer);
  virtual void SetDefaultRenderer(vtkRenderer*);
 
 
  vtkGetObjectMacro(CurrentRenderer, vtkRenderer);
  virtual void SetCurrentRenderer(vtkRenderer*);
 
  virtual void OnChar();
 
 
  static void ComputeDisplayToWorld(
    vtkRenderer* ren, double x, double y, double z, double worldPt[4]);
  static void ComputeWorldToDisplay(
    vtkRenderer* ren, double x, double y, double z, double displayPt[3]);
 
 
  void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr);
  void ReleaseFocus();
 
protected:
  vtkInteractorObserver();
  ~vtkInteractorObserver() override;
 
 
  virtual void StartInteraction();
  virtual void EndInteraction();
 
  static void ProcessEvents(
    vtkObject* object, unsigned long event, void* clientdata, void* calldata);
 
 
  void ComputeDisplayToWorld(double x, double y, double z, double worldPt[4]);
  void ComputeWorldToDisplay(double x, double y, double z, double displayPt[3]);
 
  // The state of the widget, whether on or off (observing events or not)
  int Enabled;
 
  // Used to process events
  vtkCallbackCommand* EventCallbackCommand;    // subclasses use one
  vtkCallbackCommand* KeyPressCallbackCommand; // listens to key activation
 
  // Priority at which events are processed
  float Priority;
 
  // This variable controls whether the picking is managed by the Picking
  // Manager process or not. True by default.
  bool PickingManaged;
 
  virtual void RegisterPickers();
 
  void UnRegisterPickers();
 
  vtkPickingManager* GetPickingManager();
 
  vtkAssemblyPath* GetAssemblyPath(double X, double Y, double Z, vtkAbstractPropPicker* picker);
 
  // Keypress activation controls
  vtkTypeBool KeyPressActivation;
  char KeyPressActivationValue;
 
  // Used to associate observers with the interactor
  vtkRenderWindowInteractor* Interactor;
 
  // Internal ivars for processing events
  vtkRenderer* CurrentRenderer;
  vtkRenderer* DefaultRenderer;
 
  unsigned long CharObserverTag;
  unsigned long DeleteObserverTag;
 
  // The mediator used to request resources from the interactor.
  vtkObserverMediator* ObserverMediator;
  int RequestCursorShape(int requestedShape);
 
private:
  vtkInteractorObserver(const vtkInteractorObserver&) = delete;
  void operator=(const vtkInteractorObserver&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif