vtkRenderWindowInteractor3D.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkRenderWindowInteractor3D.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkRenderWindowInteractor3D_h
#define vtkRenderWindowInteractor3D_h

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkRenderWindowInteractor.h"

class vtkCamera;

class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWindowInteractor
{
public:
  static vtkRenderWindowInteractor3D *New();

  vtkTypeMacro(vtkRenderWindowInteractor3D,vtkRenderWindowInteractor);
  void PrintSelf(ostream& os, vtkIndent indent);


  virtual void Enable();
  virtual void Disable();

  void TerminateApp(void);

  virtual vtkAbstractPropPicker *CreateDefaultPicker();


  virtual double *GetWorldEventPosition(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return NULL;
    }
    return this->WorldEventPositions[pointerIndex];
  }
  virtual double *GetLastWorldEventPosition(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return NULL;
    }
    return this->LastWorldEventPositions[pointerIndex];
  }
  virtual double *GetWorldEventOrientation(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return NULL;
    }
    return this->WorldEventOrientations[pointerIndex];
  }
  virtual double *GetLastWorldEventOrientation(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return NULL;
    }
    return this->LastWorldEventOrientations[pointerIndex];
  }


  virtual void SetPhysicalEventPosition(double x, double y, double z, int pointerIndex)
  {
    if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
    {
      return;
    }
    vtkDebugMacro(
      << this->GetClassName() << " (" << this
      << "): setting PhysicalEventPosition to ("
      << x << "," << y << "," << z
      << ") for pointerIndex number " << pointerIndex);
    if (this->PhysicalEventPositions[pointerIndex][0] != x ||
        this->PhysicalEventPositions[pointerIndex][1] != y ||
        this->PhysicalEventPositions[pointerIndex][2] != z ||
        this->LastPhysicalEventPositions[pointerIndex][0] != x ||
        this->LastPhysicalEventPositions[pointerIndex][1] != y ||
        this->LastPhysicalEventPositions[pointerIndex][2] != z)
    {
      this->LastPhysicalEventPositions[pointerIndex][0] = this->PhysicalEventPositions[pointerIndex][0];
      this->LastPhysicalEventPositions[pointerIndex][1] = this->PhysicalEventPositions[pointerIndex][1];
      this->LastPhysicalEventPositions[pointerIndex][2] = this->PhysicalEventPositions[pointerIndex][2];
      this->PhysicalEventPositions[pointerIndex][0] = x;
      this->PhysicalEventPositions[pointerIndex][1] = y;
      this->PhysicalEventPositions[pointerIndex][2] = z;
      this->Modified();
    }
  }


  virtual void SetWorldEventPosition(double x, double y, double z, int pointerIndex)
  {
    if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
    {
      return;
    }
    vtkDebugMacro(
      << this->GetClassName() << " (" << this
      << "): setting WorldEventPosition to ("
      << x << "," << y << "," << z
      << ") for pointerIndex number " << pointerIndex);
    if (this->WorldEventPositions[pointerIndex][0] != x ||
        this->WorldEventPositions[pointerIndex][1] != y ||
        this->WorldEventPositions[pointerIndex][2] != z ||
        this->LastWorldEventPositions[pointerIndex][0] != x ||
        this->LastWorldEventPositions[pointerIndex][1] != y ||
        this->LastWorldEventPositions[pointerIndex][2] != z)
    {
      this->LastWorldEventPositions[pointerIndex][0] = this->WorldEventPositions[pointerIndex][0];
      this->LastWorldEventPositions[pointerIndex][1] = this->WorldEventPositions[pointerIndex][1];
      this->LastWorldEventPositions[pointerIndex][2] = this->WorldEventPositions[pointerIndex][2];
      this->WorldEventPositions[pointerIndex][0] = x;
      this->WorldEventPositions[pointerIndex][1] = y;
      this->WorldEventPositions[pointerIndex][2] = z;
      this->Modified();
    }
  }
  virtual void SetWorldEventOrientation(double w, double x, double y, double z, int pointerIndex)
  {
    if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
    {
      return;
    }
    vtkDebugMacro(
      << this->GetClassName() << " (" << this
      << "): setting WorldEventOrientation to ("
      << w << "," << x << "," << y << "," << z
      << ") for pointerIndex number " << pointerIndex);
    if (this->WorldEventOrientations[pointerIndex][0] != w ||
        this->WorldEventOrientations[pointerIndex][1] != x ||
        this->WorldEventOrientations[pointerIndex][2] != y ||
        this->WorldEventOrientations[pointerIndex][3] != z ||
        this->LastWorldEventOrientations[pointerIndex][0] != w ||
        this->LastWorldEventOrientations[pointerIndex][1] != x ||
        this->LastWorldEventOrientations[pointerIndex][2] != y ||
        this->LastWorldEventOrientations[pointerIndex][3] != z)
    {
      this->LastWorldEventOrientations[pointerIndex][0] = this->WorldEventOrientations[pointerIndex][0];
      this->LastWorldEventOrientations[pointerIndex][1] = this->WorldEventOrientations[pointerIndex][1];
      this->LastWorldEventOrientations[pointerIndex][2] = this->WorldEventOrientations[pointerIndex][2];
      this->LastWorldEventOrientations[pointerIndex][3] = this->WorldEventOrientations[pointerIndex][3];
      this->WorldEventOrientations[pointerIndex][0] = w;
      this->WorldEventOrientations[pointerIndex][1] = x;
      this->WorldEventOrientations[pointerIndex][2] = y;
      this->WorldEventOrientations[pointerIndex][3] = z;
      this->Modified();
    }
  }


  virtual void RightButtonPressEvent();
  virtual void RightButtonReleaseEvent();


  vtkSetVector2Macro(TouchPadPosition,float);
  vtkGetVector2Macro(TouchPadPosition,float);


  virtual void SetPhysicalTranslation(vtkCamera *, double, double, double) {};
  virtual double *GetPhysicalTranslation(vtkCamera *) { return NULL; };


  void SetTranslation3D(double val[3]);
  vtkGetVector3Macro(Translation3D, double);
  vtkGetVector3Macro(LastTranslation3D, double);

protected:
  vtkRenderWindowInteractor3D();
  ~vtkRenderWindowInteractor3D();

  int     MouseInWindow;
  int     StartedMessageLoop;
  float TouchPadPosition[2];
  double Translation3D[3];
  double LastTranslation3D[3];

  bool Done;  // is the event loop done running

  double   WorldEventPositions[VTKI_MAX_POINTERS][3];
  double   LastWorldEventPositions[VTKI_MAX_POINTERS][3];
  double   PhysicalEventPositions[VTKI_MAX_POINTERS][3];
  double   LastPhysicalEventPositions[VTKI_MAX_POINTERS][3];
  double   StartingPhysicalEventPositions[VTKI_MAX_POINTERS][3];
  double   WorldEventOrientations[VTKI_MAX_POINTERS][4];
  double   LastWorldEventOrientations[VTKI_MAX_POINTERS][4];
  virtual void RecognizeGesture(vtkCommand::EventIds);

private:
  vtkRenderWindowInteractor3D(const vtkRenderWindowInteractor3D&) VTK_DELETE_FUNCTION;  // Not implemented.
  void operator=(const vtkRenderWindowInteractor3D&) VTK_DELETE_FUNCTION;  // Not implemented.
};

#endif