vtkPVXYChartView.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPVXYChartView_h
#define vtkPVXYChartView_h
 
#include "vtkAxis.h" //for enums.
#include "vtkPVContextView.h"
#include "vtkRemotingViewsModule.h" //needed for exports
 
class vtkChart;
class vtkPVPlotTime;
class vtkChartWarning;
 
#define GENERATE_AXIS_FUNCTIONS(name, type)                                                        \
  void SetLeft##name(type value) { Set##name(vtkAxis::LEFT, value); }                              \
  void SetBottom##name(type value) { Set##name(vtkAxis::BOTTOM, value); }                          \
  void SetRight##name(type value) { Set##name(vtkAxis::RIGHT, value); }                            \
  void SetTop##name(type value) { Set##name(vtkAxis::TOP, value); }
 
#define GENERATE_AXIS_FUNCTIONS2(name, type1, type2)                                               \
  void SetLeft##name(type1 value1, type2 value2) { Set##name(vtkAxis::LEFT, value1, value2); }     \
  void SetBottom##name(type1 value1, type2 value2) { Set##name(vtkAxis::BOTTOM, value1, value2); } \
  void SetRight##name(type1 value1, type2 value2) { Set##name(vtkAxis::RIGHT, value1, value2); }   \
  void SetTop##name(type1 value1, type2 value2) { Set##name(vtkAxis::TOP, value1, value2); }
 
#define GENERATE_AXIS_FUNCTIONS3(name, type1, type2, type3)                                        \
  void SetLeft##name(type1 value1, type2 value2, type3 value3)                                     \
  {                                                                                                \
    Set##name(vtkAxis::LEFT, value1, value2, value3);                                              \
  }                                                                                                \
  void SetBottom##name(type1 value1, type2 value2, type3 value3)                                   \
  {                                                                                                \
    Set##name(vtkAxis::BOTTOM, value1, value2, value3);                                            \
  }                                                                                                \
  void SetRight##name(type1 value1, type2 value2, type3 value3)                                    \
  {                                                                                                \
    Set##name(vtkAxis::RIGHT, value1, value2, value3);                                             \
  }                                                                                                \
  void SetTop##name(type1 value1, type2 value2, type3 value3)                                      \
  {                                                                                                \
    Set##name(vtkAxis::TOP, value1, value2, value3);                                               \
  }
 
class VTKREMOTINGVIEWS_EXPORT vtkPVXYChartView : public vtkPVContextView
{
public:
  static vtkPVXYChartView* New();
  vtkTypeMacro(vtkPVXYChartView, vtkPVContextView);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetChartType(const char* type);
  void SetChartTypeToLine() { this->SetChartType("Line"); }
  void SetChartTypeToPoint() { this->SetChartType("Point"); }
  void SetChartTypeToBar() { this->SetChartType("Bar"); }
  void SetChartTypeToBag() { this->SetChartType("Bag"); }
  void SetChartTypeToBox() { this->SetChartType("Box"); }
  void SetChartTypeToArea() { this->SetChartType("Area"); }
  void SetChartTypeToFunctionalBag() { this->SetChartType("FunctionalBag"); }
  void SetChartTypeToImage() { this->SetChartType("Image"); }
  void SetChartTypeToParallelCoordinates() { this->SetChartType("ParallelCoordinates"); }
 
 
  void SetTitleFont(const char* family, int pointSize, bool bold, bool italic) override;
  void SetTitleFontFamily(const char* family) override;
  void SetTitleFontSize(int pointSize) override;
  void SetTitleBold(bool bold) override;
  void SetTitleItalic(bool italic) override;
  void SetTitleFontFile(const char* file) override;
  const char* GetTitleFontFamily() override;
  int GetTitleFontSize() override;
  int GetTitleFontBold() override;
  int GetTitleFontItalic() override;
 
 
  void SetTitleColor(double red, double green, double blue) override;
  double* GetTitleColor() override;
 
 
  void SetTitleAlignment(int alignment) override;
  int GetTitleAlignment() override;
 
  void SetLegendVisibility(int visible);
 
  void SetLegendLocation(int location);
 
  void SetLegendPosition(int x, int y);
 
  void SetLegendFontFamily(const char* family);
 
  void SetLegendFontFile(const char* file);
 
  void SetLegendFontSize(int pointSize);
 
  void SetLegendBold(bool bold);
 
  void SetLegendItalic(bool italic);
 
  void SetLegendSymbolWidth(int width);
 
 
  void SetGridVisibility(int index, bool visible);
  GENERATE_AXIS_FUNCTIONS(GridVisibility, bool);
 
 
  void SetAxisColor(int index, double red, double green, double blue);
  GENERATE_AXIS_FUNCTIONS3(AxisColor, double, double, double);
 
 
  void SetGridColor(int index, double red, double green, double blue);
  GENERATE_AXIS_FUNCTIONS3(GridColor, double, double, double);
 
 
  void SetAxisLabelVisibility(int index, bool visible);
  GENERATE_AXIS_FUNCTIONS(AxisLabelVisibility, bool);
 
  void SetAxisLabelFont(int index, const char* family, int pointSize, bool bold, bool italic);
 
 
  void SetAxisLabelFontFamily(int index, const char* family);
  GENERATE_AXIS_FUNCTIONS(AxisLabelFontFamily, const char*);
 
 
  void SetAxisLabelFontFile(int index, const char* file);
  GENERATE_AXIS_FUNCTIONS(AxisLabelFontFile, const char*);
 
 
  void SetAxisLabelFontSize(int index, int pointSize);
  GENERATE_AXIS_FUNCTIONS(AxisLabelFontSize, int);
 
 
  void SetAxisLabelBold(int index, bool bold);
  GENERATE_AXIS_FUNCTIONS(AxisLabelBold, bool);
 
 
  void SetAxisLabelItalic(int index, bool italic);
  GENERATE_AXIS_FUNCTIONS(AxisLabelItalic, bool);
 
 
  void SetAxisLabelColor(int index, double red, double green, double blue);
  GENERATE_AXIS_FUNCTIONS3(AxisLabelColor, double, double, double);
 
 
  void SetAxisLabelNotation(int index, int notation);
  GENERATE_AXIS_FUNCTIONS(AxisLabelNotation, int);
 
 
  void SetAxisLabelPrecision(int index, int precision);
  GENERATE_AXIS_FUNCTIONS(AxisLabelPrecision, int);
 
 
  GENERATE_AXIS_FUNCTIONS(AxisRangeMinimum, double);
  GENERATE_AXIS_FUNCTIONS(AxisRangeMaximum, double);
 
 
  void SetAxisUseCustomRange(int index, bool useCustomRange);
  GENERATE_AXIS_FUNCTIONS(AxisUseCustomRange, bool);
 
 
  void SetAxisLogScale(int index, bool logScale);
  GENERATE_AXIS_FUNCTIONS(AxisLogScale, bool);
 
 
  void SetAxisTitle(int index, const char* title);
  GENERATE_AXIS_FUNCTIONS(AxisTitle, const char*);
 
  void SetAxisTitleFont(int index, const char* family, int pointSize, bool bold, bool italic);
 
 
  void SetAxisTitleFontFamily(int index, const char* family);
  GENERATE_AXIS_FUNCTIONS(AxisTitleFontFamily, const char*);
 
 
  void SetAxisTitleFontFile(int index, const char* file);
  GENERATE_AXIS_FUNCTIONS(AxisTitleFontFile, const char*);
 
 
  void SetAxisTitleFontSize(int index, int pointSize);
  GENERATE_AXIS_FUNCTIONS(AxisTitleFontSize, int);
 
 
  void SetAxisTitleBold(int index, bool bold);
  GENERATE_AXIS_FUNCTIONS(AxisTitleBold, bool);
 
 
  void SetAxisTitleItalic(int index, bool italic);
  GENERATE_AXIS_FUNCTIONS(AxisTitleItalic, bool);
 
 
  void SetAxisTitleColor(int index, double red, double green, double blue);
  GENERATE_AXIS_FUNCTIONS3(AxisTitleColor, double, double, double);
 
 
  void SetAxisUseCustomLabels(int index, bool useCustomLabels);
  GENERATE_AXIS_FUNCTIONS(AxisUseCustomLabels, bool);
 
 
  void SetAxisLabelsNumber(int axis, int number);
  GENERATE_AXIS_FUNCTIONS(AxisLabelsNumber, int);
 
 
  void SetAxisLabels(int axis, int index, const std::string& value, const std::string& label);
  GENERATE_AXIS_FUNCTIONS3(AxisLabels, int, const std::string&, const std::string&);
 
  void SetTooltipLabelFormat(const vtkStdString& labelFormat);
  void SetTooltipNotation(int notation);
  void SetTooltipPrecision(int precision);
 
 
  vtkSetMacro(HideTimeMarker, bool);
  vtkGetMacro(HideTimeMarker, bool);
 
 
  vtkGetMacro(SortByXAxis, bool);
  vtkSetMacro(SortByXAxis, bool);
 
  static void SetIgnoreNegativeLogAxisWarning(bool val)
  {
    vtkPVXYChartView::IgnoreNegativeLogAxisWarning = val;
  }
  static bool GetIgnoreNegativeLogAxisWarning()
  {
    return vtkPVXYChartView::IgnoreNegativeLogAxisWarning;
  }
 
  virtual vtkChart* GetChart();
 
  vtkAbstractContextItem* GetContextItem() override;
 
  void SetSelection(vtkChartRepresentation* repr, vtkSelection* selection) override;
 
  void Update() override;
 
protected:
  vtkPVXYChartView();
  ~vtkPVXYChartView() override;
 
  void SetAxisRangeMinimum(int index, double min);
  void SetAxisRangeMaximum(int index, double max);
 
  void Render(bool interactive) override;
 
 
  vtkChart* Chart;
  vtkPVPlotTime* PlotTime;
  vtkChartWarning* LogScaleWarningLabel;
 
  void SelectionChanged();
 
  bool HideTimeMarker;
  bool SortByXAxis;
 
  static bool IgnoreNegativeLogAxisWarning;
 
private:
  vtkPVXYChartView(const vtkPVXYChartView&) = delete;
  void operator=(const vtkPVXYChartView&) = delete;
 
  class vtkInternals;
  vtkInternals* Internals;
};
 
#endif