vtkDataRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2008 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
 
#ifndef vtkDataRepresentation_h
#define vtkDataRepresentation_h
 
#include "vtkPassInputTypeAlgorithm.h"
#include "vtkViewsCoreModule.h" // For export macro
#include "vtkWrappingHints.h"   // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAlgorithmOutput;
class vtkAnnotationLayers;
class vtkAnnotationLink;
class vtkDataObject;
class vtkSelection;
class vtkStringArray;
class vtkTrivialProducer;
class vtkView;
class vtkViewTheme;
 
class VTKVIEWSCORE_EXPORT VTK_MARSHALAUTO vtkDataRepresentation : public vtkPassInputTypeAlgorithm
{
public:
  static vtkDataRepresentation* New();
  vtkTypeMacro(vtkDataRepresentation, vtkPassInputTypeAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  vtkAlgorithmOutput* GetInputConnection(int port = 0, int index = 0)
  {
    return this->Superclass::GetInputConnection(port, index);
  }

  vtkAnnotationLink* GetAnnotationLink() { return this->AnnotationLinkInternal; }
  void SetAnnotationLink(vtkAnnotationLink* link);

  virtual void ApplyViewTheme(vtkViewTheme* vtkNotUsed(theme)) {}

  void Select(vtkView* view, vtkSelection* selection) { this->Select(view, selection, false); }
  void Select(vtkView* view, vtkSelection* selection, bool extend);

  void Annotate(vtkView* view, vtkAnnotationLayers* annotations)
  {
    this->Annotate(view, annotations, false);
  }
  void Annotate(vtkView* view, vtkAnnotationLayers* annotations, bool extend);


  vtkSetMacro(Selectable, bool);
  vtkGetMacro(Selectable, bool);
  vtkBooleanMacro(Selectable, bool);

  void UpdateSelection(vtkSelection* selection) { this->UpdateSelection(selection, false); }
  void UpdateSelection(vtkSelection* selection, bool extend);

  void UpdateAnnotations(vtkAnnotationLayers* annotations)
  {
    this->UpdateAnnotations(annotations, false);
  }
  void UpdateAnnotations(vtkAnnotationLayers* annotations, bool extend);

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

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

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


  vtkSetMacro(SelectionType, int);
  vtkGetMacro(SelectionType, int);


  virtual void SetSelectionArrayNames(vtkStringArray* names);
  vtkGetObjectMacro(SelectionArrayNames, vtkStringArray);


  virtual void SetSelectionArrayName(const char* name);
  virtual const char* GetSelectionArrayName();

  virtual vtkSelection* ConvertSelection(vtkView* view, vtkSelection* selection);
 
protected:
  vtkDataRepresentation();
  ~vtkDataRepresentation() override;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override
  {
    return 1;
  }

  virtual void ProcessEvents(vtkObject* caller, unsigned long eventId, void* callData);


  virtual void SetAnnotationLinkInternal(vtkAnnotationLink* link);
  vtkAnnotationLink* AnnotationLinkInternal;
 
  // Whether its representation can handle a selection.
  bool Selectable;

  int SelectionType;

  vtkStringArray* SelectionArrayNames;
 
  friend class vtkView;
  friend class vtkRenderView;
  class Command;
  friend class Command;
  Command* Observer;
 
  // ------------------------------------------------------------------------
  // Methods to override in subclasses
  // ------------------------------------------------------------------------

  virtual bool AddToView(vtkView* vtkNotUsed(view)) { return true; }

  virtual bool RemoveFromView(vtkView* vtkNotUsed(view)) { return true; }

  virtual vtkAnnotationLayers* ConvertAnnotations(vtkView* view, vtkAnnotationLayers* annotations);
 
  vtkTrivialProducer* GetInternalInput(int port, int conn);
  void SetInternalInput(int port, int conn, vtkTrivialProducer* producer);
 
private:
  vtkDataRepresentation(const vtkDataRepresentation&) = delete;
  void operator=(const vtkDataRepresentation&) = delete;
 
  class Internals;
  Internals* Implementation;
};
 
VTK_ABI_NAMESPACE_END
#endif