pqRenderView.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause
#ifndef pqRenderView_h
#define pqRenderView_h

#include "pqRenderViewBase.h"
#include <QColor>  // needed for return type.
#include <QCursor> // needed for return type.

class pqDataRepresentation;
class QAction;
class vtkCollection;
class vtkIntArray;
class vtkSMRenderViewProxy;

// This is a PQ abstraction of a render view.
class PQCORE_EXPORT pqRenderView : public pqRenderViewBase
{
  Q_OBJECT
  typedef pqRenderViewBase Superclass;

public:
  static QString renderViewType() { return "RenderView"; }

  // Constructor:
  // \c group :- SManager registration group name.
  // \c name  :- SManager registration name.
  // \c view  :- RenderView proxy.
  // \c server:- server on which the proxy is created.
  // \c parent:- QObject parent.
  pqRenderView(const QString& group, const QString& name, vtkSMViewProxy* renModule,
    pqServer* server, QObject* parent = nullptr);

  // This version allows subclasses to substitute their own renderViewType.
  pqRenderView(const QString& tname, const QString& group, const QString& name,
    vtkSMViewProxy* renModule, pqServer* server, QObject* parent = nullptr);

  // Destructor.
  ~pqRenderView() override;

  virtual vtkSMRenderViewProxy* getRenderViewProxy() const;

  void resetCamera(bool closest = false, double offsetRatio = 0.9) override;

  virtual void resetCenterOfRotation();

  virtual void resetParallelScale();

  virtual bool getOrientationAxesVisibility() const;

  virtual bool getOrientationAxesInteractivity() const;

  virtual QColor getOrientationAxesLabelColor() const;

  virtual QColor getOrientationAxesOutlineColor() const;

  virtual bool getResetCenterWithCamera() const { return this->ResetCenterWithCamera; }

  virtual bool getUseMultipleRepresentationSelection() const
  {
    return this->UseMultipleRepresentationSelection;
  }

  virtual bool getCenterAxesVisibility() const;

  virtual void getCenterOfRotation(double center[3]) const;

  bool supportsUndo() const override { return true; }


  bool canUndo() const override;
  bool canRedo() const override;

  bool supportsCapture() const override { return true; }


  virtual void linkUndoStack(pqRenderView* other);
  virtual void unlinkUndoStack(pqRenderView* other);

  virtual void clearUndoStack();

  virtual void resetViewDirection(
    double look_x, double look_y, double look_z, double up_x, double up_y, double up_z);
  virtual void adjustView(const int& adjustType, const double& angle);
  virtual void adjustAzimuth(const double& value);
  virtual void adjustElevation(const double& value);
  virtual void adjustRoll(const double& value);
  virtual void adjustZoom(const double& value);
  virtual void applyIsometricView();
  virtual void resetViewDirectionToPositiveX();
  virtual void resetViewDirectionToNegativeX();
  virtual void resetViewDirectionToPositiveY();
  virtual void resetViewDirectionToNegativeY();
  virtual void resetViewDirectionToPositiveZ();
  virtual void resetViewDirectionToNegativeZ();


  virtual void setCursor(const QCursor&);
  virtual QCursor cursor();


  void setCursorVisible(bool visible);
  bool cursorVisible();

  virtual void selectCellsOnSurface(int rectangle[4],
    int selectionModifier = pqView::PV_SELECTION_DEFAULT, const char* array = nullptr);
  virtual void selectPointsOnSurface(int rectangle[4],
    int selectionModifier = pqView::PV_SELECTION_DEFAULT, const char* array = nullptr);

  virtual pqDataRepresentation* pick(int pos[2]);

  virtual pqDataRepresentation* pickBlock(int pos[2], unsigned int& flatIndex, int& rank);

  virtual void selectFrustumCells(
    int rectangle[4], int selectionModifier = pqView::PV_SELECTION_DEFAULT);
  virtual void selectFrustumPoints(
    int rectangle[4], int selectionModifier = pqView::PV_SELECTION_DEFAULT);
  virtual void selectFrustumBlocks(
    int rectangle[4], int selectionModifier = pqView::PV_SELECTION_DEFAULT);

  virtual void selectBlock(int rectangle[4], int selectionModifier = pqView::PV_SELECTION_DEFAULT);


  virtual void selectPolygonPoints(
    vtkIntArray* polygon, int selectionModifier = pqView::PV_SELECTION_DEFAULT);
  virtual void selectPolygonCells(
    vtkIntArray* polygon, int selectionModifier = pqView::PV_SELECTION_DEFAULT);

Q_SIGNALS:
  // Triggered when interaction mode change underneath
  void updateInteractionMode(int mode);

public Q_SLOTS:
  // Toggle the orientation axes visibility.
  virtual void setOrientationAxesVisibility(bool visible);

  // Toggle orientation axes interactivity.
  virtual void setOrientationAxesInteractivity(bool interactive);

  // Set orientation axes label color.
  virtual void setOrientationAxesLabelColor(const QColor&);

  // Set orientation axes outline color.
  virtual void setOrientationAxesOutlineColor(const QColor&);

  // Set the center of rotation. For this to work,
  // one should have appropriate interaction style (vtkPVInteractorStyle subclass)
  // and camera manipulators that use the center of rotation.
  // They are setup correctly by default.
  virtual void setCenterOfRotation(double x, double y, double z);
  virtual void setCenterOfRotation(double xyz[3])
  {
    this->setCenterOfRotation(xyz[0], xyz[1], xyz[2]);
  }

  // Set the parallel scale
  virtual void setParallelScale(double scale);

  // Toggle center axes visibility.
  virtual void setCenterAxesVisibility(bool visible);

  virtual void setResetCenterWithCamera(bool b) { this->ResetCenterWithCamera = b; }

  virtual void setUseMultipleRepresentationSelection(bool b)
  {
    this->UseMultipleRepresentationSelection = b;
  }

  virtual void linkToOtherView();

  void undo() override;

  void redo() override;

  virtual void resetCenterOfRotationIfNeeded() { this->onResetCameraEvent(); }

  virtual void updateInteractionMode(pqOutputPort* opPort);

protected Q_SLOTS:
  virtual void onInteractionModeChange();

  virtual void onGenericFilmicPresetsChange();

  // Called when vtkSMRenderViewProxy fires ResetCameraEvent.
  virtual void onResetCameraEvent();

  virtual void onUndoStackChanged();

protected: // NOLINT(readability-redundant-access-specifiers)
  virtual void fakeUndoRedo(bool redo, bool self);

  virtual void fakeInteraction(bool start);

  QWidget* createWidget() override;

  void initialize() override;

  // When true, the camera center of rotation will be reset when the
  // user reset the camera.
  bool ResetCenterWithCamera;

  // When true, the selection will be performed on all representations.
  bool UseMultipleRepresentationSelection;

private:
  void selectOnSurfaceInternal(int rect[4], QList<pqOutputPort*>&, bool select_points,
    int selectionModifier, bool select_blocks, const char* array = nullptr);

  void selectPolygonInternal(vtkIntArray* polygon, QList<pqOutputPort*>&, bool select_points,
    int selectionModifier, bool select_blocks);

  void emitSelectionSignal(QList<pqOutputPort*> outputPorts, int selectionModifier);

  void collectSelectionPorts(vtkCollection* selectedRepresentations,
    vtkCollection* selectionSources, QList<pqOutputPort*>& pqPorts, int selectionModifier,
    bool select_blocks);

  void InternalConstructor(vtkSMViewProxy* renModule);

  class pqInternal;
  pqInternal* Internal;
};

#endif