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 "vtkParaViewDeprecation.h" // for PARAVIEW_DEPRECATION
#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();
 
 
  PARAVIEW_DEPRECATED_IN_5_11_0("Use selectCellsOnSurface instead.")
  virtual void selectOnSurface(int rectangle[4],
    int selectionModifier = pqView::PV_SELECTION_DEFAULT, const char* array = nullptr)
  {
    this->selectCellsOnSurface(rectangle, selectionModifier, array);
  }
  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);
 
 
  PARAVIEW_DEPRECATED_IN_5_11_0("Use selectFrustumCells instead.")
  virtual void selectFrustum(int rectangle[4]) { this->selectFrustumCells(rectangle); }
  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 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