vtkPVDataRepresentation.h

Go to the documentation of this file.

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

#include "vtkCommand.h" // needed for vtkCommand
#include "vtkDataRepresentation.h"
#include "vtkRemotingViewsModule.h" // needed for exports
#include "vtkWeakPointer.h"         // needed for vtkWeakPointer
#include <string>                   // needed for string

class vtkInformationRequestKey;

class VTKREMOTINGVIEWS_EXPORT vtkPVDataRepresentation : public vtkDataRepresentation
{
public:
  vtkTypeMacro(vtkPVDataRepresentation, vtkDataRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual int ProcessViewRequest(
    vtkInformationRequestKey* request_type, vtkInformation* inInfo, vtkInformation* outInfo);

  virtual void MarkModified();

  virtual unsigned int Initialize(unsigned int minIdAvailable, unsigned int maxIdAvailable);

  unsigned int GetUniqueIdentifier() { return this->UniqueIdentifier; }

  virtual void SetVisibility(bool val) { this->Visibility = val; }
  vtkGetMacro(Visibility, bool);

  virtual vtkDataObject* GetRenderedDataObject(int vtkNotUsed(port))
  {
    return this->GetInputDataObject(0, 0);
  }


  virtual void SetUpdateTime(double time);
  vtkGetMacro(UpdateTime, double);


  vtkGetMacro(UpdateTimeValid, bool);
  void ResetUpdateTime();


  virtual void SetForcedCacheKey(double val) { this->ForcedCacheKey = val; }
  virtual void SetForceUseCache(bool val) { this->ForceUseCache = val; }
  vtkGetMacro(ForcedCacheKey, double);
  vtkGetMacro(ForceUseCache, bool);

  double GetCacheKey() const;


  bool AddToView(vtkView* view) override;
  bool RemoveFromView(vtkView* view) override;

  vtkAlgorithmOutput* GetInternalOutputPort() override { return this->GetInternalOutputPort(0); }
  vtkAlgorithmOutput* GetInternalOutputPort(int port) override
  {
    return this->GetInternalOutputPort(port, 0);
  }
  vtkAlgorithmOutput* GetInternalOutputPort(int port, int conn) override;

  vtkView* GetView() const;

  vtkMTimeType GetPipelineDataTime();


  virtual void SetLogName(const std::string& name) { this->LogName = name; }
  const std::string& GetLogName() const { return this->LogName; }


  vtkGetMacro(HasTemporalPipeline, bool);
  vtkSetMacro(HasTemporalPipeline, bool);

  bool GetNeedsUpdate();

  enum
  {
    SkippedUpdateDataEvent = vtkCommand::UserEvent + 91,
    UpdateTimeChangedEvent,
  };


  void SetInputConnection(int port, vtkAlgorithmOutput* input) override;
  using Superclass::SetInputConnection;
  void AddInputConnection(int port, vtkAlgorithmOutput* input) override;
  using Superclass::AddInputConnection;

  virtual void SetArrayIdNames(
    const char* vtkNotUsed(pointArray), const char* vtkNotUsed(cellArray)){};

protected:
  vtkPVDataRepresentation();
  ~vtkPVDataRepresentation() override;

  vtkExecutive* CreateDefaultExecutive() override;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  int RequestUpdateTime(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  double UpdateTime;
  bool UpdateTimeValid;
  unsigned int UniqueIdentifier;

private:
  vtkPVDataRepresentation(const vtkPVDataRepresentation&) = delete;
  void operator=(const vtkPVDataRepresentation&) = delete;

  bool Visibility;
  bool ForceUseCache;
  double ForcedCacheKey;
  double CacheKey;

  bool HasTemporalPipeline;

  class Internals;
  Internals* Implementation;
  vtkWeakPointer<vtkView> View;
  std::string LogName;
};

#endif