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