vtkSpreadSheetView.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSpreadSheetView_h
#define vtkSpreadSheetView_h
 
#include "vtkPVView.h"
#include "vtkRemotingViewsModule.h" //needed for exports
 
#include <string> // for std::string
 
class vtkCSVExporter;
class vtkClientServerMoveData;
class vtkMarkSelectedRows;
class vtkReductionFilter;
class vtkSortedTableStreamer;
class vtkTable;
class vtkVariant;
 
class VTKREMOTINGVIEWS_EXPORT vtkSpreadSheetView : public vtkPVView
{
public:
  static vtkSpreadSheetView* New();
  vtkTypeMacro(vtkSpreadSheetView, vtkPVView);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(Identifier, vtkTypeUInt32);
  vtkGetMacro(Identifier, vtkTypeUInt32);
 
  void StillRender() override { this->StreamToClient(); }
 
  void InteractiveRender() override { this->StreamToClient(); }
 
  void Update() override;
 
 
  void SetShowExtractedSelection(bool);
  vtkBooleanMacro(ShowExtractedSelection, bool);
  vtkGetMacro(ShowExtractedSelection, bool);
 
 
  vtkSetMacro(GenerateCellConnectivity, bool);
  vtkGetMacro(GenerateCellConnectivity, bool);
  vtkBooleanMacro(GenerateCellConnectivity, bool);
 
 
  vtkSetMacro(ShowFieldData, bool);
  vtkGetMacro(ShowFieldData, bool);
  vtkBooleanMacro(ShowFieldData, bool);
 
 
  vtkSetMacro(FieldAssociation, int);
  vtkGetMacro(FieldAssociation, int);
 
 
  void OrderColumnsByList(bool enable);
  void InitializeOrderedColumnList();
  std::vector<std::string> GetOrderedColumnList();
  void SetOrderedColumnList(std::vector<std::string> list);
  void ClearOrderedColumnList();
 
 
  void HideColumnByName(const char* columnName);
  bool IsColumnHiddenByName(const char* columnName);
  void ClearHiddenColumnsByName();
 
  void HideColumnByLabel(const char* columnLabel);
  bool IsColumnHiddenByLabel(const std::string& columnLabel);
  void ClearHiddenColumnsByLabel();
 
  virtual vtkIdType GetNumberOfColumns();
 
  virtual vtkIdType GetNumberOfRows();
 
  virtual const char* GetColumnName(vtkIdType index);
 
 
  virtual bool IsColumnInternal(vtkIdType index);
  virtual bool IsColumnInternal(const char* columnName);
 
 
  virtual std::string GetColumnLabel(vtkIdType index);
  virtual std::string GetColumnLabel(const char* columnName);
 
  vtkIdType GetColumnByName(const char* columnName);
 
  virtual bool GetColumnVisibility(vtkIdType index);
 
 
  virtual vtkVariant GetValue(vtkIdType row, vtkIdType col);
  virtual vtkVariant GetValueByName(vtkIdType row, const char* columnName);
 
  virtual bool IsRowSelected(vtkIdType row);
 
  virtual bool IsAvailable(vtkIdType row);
 
  virtual bool IsDataValid(vtkIdType row, vtkIdType col);
 
  //***************************************************************************
  // Forwarded to vtkSortedTableStreamer.
  void SetColumnNameToSort(const char*);
  void SetColumnNameToSort() { this->SetColumnNameToSort(nullptr); }
 
  void SetInvertSortOrder(bool);
 
  void SetBlockSize(vtkIdType val);
 
  virtual bool Export(vtkCSVExporter* exporter);
 
  void ClearCache();
  using Superclass::ClearCache;
 
  // INTERNAL METHOD. Don't call directly.
  vtkTable* FetchBlockCallback(vtkIdType blockindex);
 
protected:
  vtkSpreadSheetView();
  ~vtkSpreadSheetView() override;
 
  int StreamToClient();
 
  void OnRepresentationUpdated();
 
  virtual vtkTable* FetchBlock(vtkIdType blockindex);
 
  bool ShowExtractedSelection = false;
  bool GenerateCellConnectivity = false;
  bool ShowFieldData = false;
  vtkSortedTableStreamer* TableStreamer;
  vtkMarkSelectedRows* TableSelectionMarker;
  vtkReductionFilter* ReductionFilter;
  vtkClientServerMoveData* DeliveryFilter;
  vtkIdType NumberOfRows;
 
  unsigned long CRMICallbackTag;
  unsigned long PRMICallbackTag;
  vtkTypeUInt32 Identifier;
 
  enum
  {
    FETCH_BLOCK_TAG = 394732
  };
 
private:
  vtkSpreadSheetView(const vtkSpreadSheetView&) = delete;
  void operator=(const vtkSpreadSheetView&) = delete;
 
  class vtkInternals;
  friend class vtkInternals;
  vtkInternals* Internals;
  bool SomethingUpdated;
 
  int FieldAssociation;
};
 
#endif