#ifndef __IDMS__INTERACTORSTYLEIMAGE__H__
#define __IDMS__INTERACTORSTYLEIMAGE__H__

#include <vtkInteractorStyleImage.h>
#include <vtkLineWidget2.h>
#include <vtkLineRepresentation.h>
#include <vtkOrientationMarkerWidget.h>
#include <vtkPlane.h>
#include <vtkPropPicker.h>
#include <vtkSmartPointer.h>

class vtkImageData;

namespace idms
{
  class VolumeActors;

  /**
   */
  class InteractorStyleImage
    : public vtkInteractorStyleImage
  {
  public:
    typedef InteractorStyleImage Self;

    enum InteractionMode
    {
      NavigationMode = 0,
      DeformationMode
    };

  public:
    vtkTypeMacro( InteractorStyleImage, vtkInteractorStyleImage );

  public:
    static Self* New( );

    void Configure( VolumeActors* actors, const int& axis );

    void SetModeToNavigation( );
    void SetModeToDeformation( );
    virtual void SetInteractor( vtkRenderWindowInteractor* interactor );

    // Description:
    // Event bindings controlling the effects of pressing mouse buttons
    // or moving the mouse.
    virtual void OnMouseMove( );
    virtual void OnLeftButtonDown( );
    virtual void OnLeftButtonUp( );
    /*
      virtual void OnMiddleButtonDown( );
      virtual void OnMiddleButtonUp( );
      virtual void OnRightButtonDown( );
      virtual void OnRightButtonUp( );
    */
    virtual void OnMouseWheelForward( );
    virtual void OnMouseWheelBackward( );

    // Description:
    // Override the "fly-to" (f keypress) for images.
    virtual void OnChar( );

    // These methods for the different interactions in different modes
    // are overridden in subclasses to perform the correct motion. Since
    // they might be called from OnTimer, they do not have mouse coord
    // parameters (use interactor's GetEventPosition and GetLastEventPosition)
    virtual void Rotate( )
      {
        std::cout << "Rotate" << std::endl;
      }
    virtual void Pan( );
    virtual void Spin( );
    virtual void Zoom( )
      {
        std::cout << "Zoom" << std::endl;
      }
    virtual void StartWindowLevel( );
    virtual void WindowLevel( );
    virtual void Pick( )
      {
        std::cout << "Pick" << std::endl;
      }
    virtual void Slice( )
      {
        std::cout << "Slice" << std::endl;
      }

    // Interaction mode entry points used internally.
    /*
      virtual void StartWindowLevel();
      virtual void EndWindowLevel();
      virtual void StartPick();
      virtual void EndPick();
      virtual void StartSlice();
      virtual void EndSlice();
    */

    // Description:
    // Set/Get current mode to 2D or 3D.  The default is 2D.  In 3D mode,
    // it is possible to rotate the camera to view oblique slices.  In Slicing
    // mode, it is possible to slice through the data, but not to generate oblique
    // views by rotating the camera.
    /*
      vtkSetClampMacro(InteractionMode, int, VTKIS_IMAGE2D, VTKIS_IMAGE_SLICING);
      vtkGetMacro(InteractionMode, int);
      void SetInteractionModeToImage2D() {
      this->SetInteractionMode(VTKIS_IMAGE2D); }
      void SetInteractionModeToImage3D() {
      this->SetInteractionMode(VTKIS_IMAGE3D); }
      void SetInteractionModeToImageSlicing() {
      this->SetInteractionMode(VTKIS_IMAGE_SLICING); }
    */

    // Description:
    // Set the orientations that will be used when the X, Y, or Z
    // keys are pressed.  See SetImageOrientation for more information.
    /*
      vtkSetVector3Macro(XViewRightVector, double);
      vtkGetVector3Macro(XViewRightVector, double);
      vtkSetVector3Macro(XViewUpVector, double);
      vtkGetVector3Macro(XViewUpVector, double);
      vtkSetVector3Macro(YViewRightVector, double);
      vtkGetVector3Macro(YViewRightVector, double);
      vtkSetVector3Macro(YViewUpVector, double);
      vtkGetVector3Macro(YViewUpVector, double);
      vtkSetVector3Macro(ZViewRightVector, double);
      vtkGetVector3Macro(ZViewRightVector, double);
      vtkSetVector3Macro(ZViewUpVector, double);
      vtkGetVector3Macro(ZViewUpVector, double);
    */

    // Description:
    // Set the view orientation, in terms of the horizontal and
    // vertical directions of the computer screen.  The first
    // vector gives the direction that will correspond to moving
    // horizontally left-to-right across the screen, and the
    // second vector gives the direction that will correspond to
    // moving bottom-to-top up the screen.  This method changes
    // the position of the camera to provide the desired view.
    /*
      void SetImageOrientation(
      const double leftToRight[3],
      const double bottomToTop[3]);
    */

    // Description:
    // Get the current image property, which is set when StartWindowLevel
    // is called immediately before StartWindowLevelEvent is generated.
    // This is the image property of the topmost vtkImageSlice in the
    // renderer or NULL if no image actors are present.
    /*
      vtkImageProperty *GetCurrentImageProperty() {
      return this->CurrentImageProperty; }
    */

  protected:
    InteractorStyleImage( );
    virtual ~InteractorStyleImage( );

    bool _PickPosition( double pos[ 3 ] );
    void _UpdateCursor( );

  private:
    // Purposely not implemented
    InteractorStyleImage( const Self& );
    Self& operator=( const Self& );

  protected:
    Self::InteractionMode Mode;

    vtkSmartPointer< vtkOrientationMarkerWidget > OrientationWidget;
    VolumeActors* Actors;
    int Axis;
    vtkSmartPointer< vtkPlane > Plane;
    vtkSmartPointer< vtkPropPicker > PropPicker;

    bool UpdatingRegion;

    vtkSmartPointer< vtkLineRepresentation > LineRep;
    vtkSmartPointer< vtkLineWidget2 >        LineWdg;

  public:
    static int SliceEvent;
  };

} // ecapseman

#endif // __IDMS__INTERACTORSTYLEIMAGE__H__

// eof - $RCSfile$