// python wrapper for vtkHierarchicalGraphPipeline
//
#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include "vtkPythonArgs.h"
#include "vtkPythonOverload.h"
#include "vtkConfigure.h"
#include <cstddef>
#include <sstream>
#include "vtkVariant.h"
#include "vtkIndent.h"
#include "vtkHierarchicalGraphPipeline.h"

extern "C" { VTK_ABI_EXPORT void PyVTKAddFile_vtkHierarchicalGraphPipeline(PyObject *); }
extern "C" { VTK_ABI_EXPORT PyObject *PyvtkHierarchicalGraphPipeline_ClassNew(); }

#ifndef DECLARED_PyvtkObject_ClassNew
extern "C" { PyObject *PyvtkObject_ClassNew(); }
#define DECLARED_PyvtkObject_ClassNew
#endif

static const char *PyvtkHierarchicalGraphPipeline_Doc =
  "vtkHierarchicalGraphPipeline - helper class for rendering graphs\nsuperimposed on a tree.\n\n"
  "Superclass: vtkObject\n\n"
  "vtkHierarchicalGraphPipeline renders bundled edges that are meant to\n"
  "be viewed as an overlay on a tree. This class is not for general use,\n"
  "but is used in the internals of vtkRenderedHierarchyRepresentation\n"
  "and vtkRenderedTreeAreaRepresentation.\n\n";


static PyObject *
PyvtkHierarchicalGraphPipeline_IsTypeOf(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "IsTypeOf");

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    int tempr = vtkHierarchicalGraphPipeline::IsTypeOf(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_IsA(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "IsA");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    int tempr = (ap.IsBound() ?
      op->IsA(temp0) :
      op->vtkHierarchicalGraphPipeline::IsA(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SafeDownCast(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "SafeDownCast");

  vtkObjectBase *temp0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkObjectBase"))
  {
    vtkHierarchicalGraphPipeline *tempr = vtkHierarchicalGraphPipeline::SafeDownCast(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_NewInstance(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "NewInstance");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkHierarchicalGraphPipeline *tempr = (ap.IsBound() ?
      op->NewInstance() :
      op->vtkHierarchicalGraphPipeline::NewInstance());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
      if (result && PyVTKObject_Check(result))
      {
        PyVTKObject_GetObject(result)->UnRegister(0);
        PyVTKObject_SetFlag(result, VTK_PYTHON_IGNORE_UNREGISTER, 1);
      }
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetActor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetActor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkActor *tempr = (ap.IsBound() ?
      op->GetActor() :
      op->vtkHierarchicalGraphPipeline::GetActor());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetLabelActor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLabelActor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkActor2D *tempr = (ap.IsBound() ?
      op->GetLabelActor() :
      op->vtkHierarchicalGraphPipeline::GetLabelActor());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetBundlingStrength(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetBundlingStrength");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  double temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetBundlingStrength(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetBundlingStrength(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetBundlingStrength(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetBundlingStrength");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    double tempr = (ap.IsBound() ?
      op->GetBundlingStrength() :
      op->vtkHierarchicalGraphPipeline::GetBundlingStrength());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetLabelArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetLabelArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetLabelArrayName(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetLabelArrayName(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetLabelArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLabelArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    const char *tempr = (ap.IsBound() ?
      op->GetLabelArrayName() :
      op->vtkHierarchicalGraphPipeline::GetLabelArrayName());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetLabelVisibility(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetLabelVisibility");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  bool temp0 = false;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetLabelVisibility(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetLabelVisibility(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetLabelVisibility(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLabelVisibility");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    bool tempr = (ap.IsBound() ?
      op->GetLabelVisibility() :
      op->vtkHierarchicalGraphPipeline::GetLabelVisibility());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_LabelVisibilityOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "LabelVisibilityOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->LabelVisibilityOn();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::LabelVisibilityOn();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_LabelVisibilityOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "LabelVisibilityOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->LabelVisibilityOff();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::LabelVisibilityOff();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetLabelTextProperty(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetLabelTextProperty");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  vtkTextProperty *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkTextProperty"))
  {
    if (ap.IsBound())
    {
      op->SetLabelTextProperty(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetLabelTextProperty(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetLabelTextProperty(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLabelTextProperty");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkTextProperty *tempr = (ap.IsBound() ?
      op->GetLabelTextProperty() :
      op->vtkHierarchicalGraphPipeline::GetLabelTextProperty());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetColorArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetColorArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetColorArrayName(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetColorArrayName(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetColorArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetColorArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    const char *tempr = (ap.IsBound() ?
      op->GetColorArrayName() :
      op->vtkHierarchicalGraphPipeline::GetColorArrayName());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetColorEdgesByArray(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetColorEdgesByArray");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  bool temp0 = false;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetColorEdgesByArray(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetColorEdgesByArray(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetColorEdgesByArray(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetColorEdgesByArray");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    bool tempr = (ap.IsBound() ?
      op->GetColorEdgesByArray() :
      op->vtkHierarchicalGraphPipeline::GetColorEdgesByArray());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_ColorEdgesByArrayOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ColorEdgesByArrayOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->ColorEdgesByArrayOn();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::ColorEdgesByArrayOn();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_ColorEdgesByArrayOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ColorEdgesByArrayOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->ColorEdgesByArrayOff();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::ColorEdgesByArrayOff();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetVisibility(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetVisibility");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  bool temp0 = false;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetVisibility(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetVisibility(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetVisibility(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetVisibility");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    bool tempr = (ap.IsBound() ?
      op->GetVisibility() :
      op->vtkHierarchicalGraphPipeline::GetVisibility());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_VisibilityOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "VisibilityOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->VisibilityOn();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::VisibilityOn();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_VisibilityOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "VisibilityOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->VisibilityOff();
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::VisibilityOff();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_ConvertSelection(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ConvertSelection");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  vtkDataRepresentation *temp0 = nullptr;
  vtkSelection *temp1 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetVTKObject(temp0, "vtkDataRepresentation") &&
      ap.GetVTKObject(temp1, "vtkSelection"))
  {
    vtkSelection *tempr = (ap.IsBound() ?
      op->ConvertSelection(temp0, temp1) :
      op->vtkHierarchicalGraphPipeline::ConvertSelection(temp0, temp1));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_PrepareInputConnections(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "PrepareInputConnections");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  vtkAlgorithmOutput *temp0 = nullptr;
  vtkAlgorithmOutput *temp1 = nullptr;
  vtkAlgorithmOutput *temp2 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetVTKObject(temp0, "vtkAlgorithmOutput") &&
      ap.GetVTKObject(temp1, "vtkAlgorithmOutput") &&
      ap.GetVTKObject(temp2, "vtkAlgorithmOutput"))
  {
    if (ap.IsBound())
    {
      op->PrepareInputConnections(temp0, temp1, temp2);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::PrepareInputConnections(temp0, temp1, temp2);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_ApplyViewTheme(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ApplyViewTheme");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  vtkViewTheme *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkViewTheme"))
  {
    if (ap.IsBound())
    {
      op->ApplyViewTheme(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::ApplyViewTheme(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetHoverArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetHoverArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetHoverArrayName(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetHoverArrayName(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetHoverArrayName(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetHoverArrayName");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    char *tempr = (ap.IsBound() ?
      op->GetHoverArrayName() :
      op->vtkHierarchicalGraphPipeline::GetHoverArrayName());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_SetSplineType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSplineType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetSplineType(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::SetSplineType(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_GetSplineType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSplineType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = (ap.IsBound() ?
      op->GetSplineType() :
      op->vtkHierarchicalGraphPipeline::GetSplineType());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHierarchicalGraphPipeline_RegisterProgress(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "RegisterProgress");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHierarchicalGraphPipeline *op = static_cast<vtkHierarchicalGraphPipeline *>(vp);

  vtkRenderView *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkRenderView"))
  {
    if (ap.IsBound())
    {
      op->RegisterProgress(temp0);
    }
    else
    {
      op->vtkHierarchicalGraphPipeline::RegisterProgress(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyMethodDef PyvtkHierarchicalGraphPipeline_Methods[] = {
  {"IsTypeOf", PyvtkHierarchicalGraphPipeline_IsTypeOf, METH_VARARGS,
   "V.IsTypeOf(string) -> int\nC++: static vtkTypeBool IsTypeOf(const char *type)\n\nReturn 1 if this class type is the same type of (or a subclass\nof) the named class. Returns 0 otherwise. This method works in\ncombination with vtkTypeMacro found in vtkSetGet.h.\n"},
  {"IsA", PyvtkHierarchicalGraphPipeline_IsA, METH_VARARGS,
   "V.IsA(string) -> int\nC++: vtkTypeBool IsA(const char *type) override;\n\nReturn 1 if this class is the same type of (or a subclass of) the\nnamed class. Returns 0 otherwise. This method works in\ncombination with vtkTypeMacro found in vtkSetGet.h.\n"},
  {"SafeDownCast", PyvtkHierarchicalGraphPipeline_SafeDownCast, METH_VARARGS,
   "V.SafeDownCast(vtkObjectBase) -> vtkHierarchicalGraphPipeline\nC++: static vtkHierarchicalGraphPipeline *SafeDownCast(\n    vtkObjectBase *o)\n\n"},
  {"NewInstance", PyvtkHierarchicalGraphPipeline_NewInstance, METH_VARARGS,
   "V.NewInstance() -> vtkHierarchicalGraphPipeline\nC++: vtkHierarchicalGraphPipeline *NewInstance()\n\n"},
  {"GetActor", PyvtkHierarchicalGraphPipeline_GetActor, METH_VARARGS,
   "V.GetActor() -> vtkActor\nC++: virtual vtkActor *GetActor()\n\nThe actor associated with the hierarchical graph.\n"},
  {"GetLabelActor", PyvtkHierarchicalGraphPipeline_GetLabelActor, METH_VARARGS,
   "V.GetLabelActor() -> vtkActor2D\nC++: virtual vtkActor2D *GetLabelActor()\n\nThe actor associated with the hierarchical graph.\n"},
  {"SetBundlingStrength", PyvtkHierarchicalGraphPipeline_SetBundlingStrength, METH_VARARGS,
   "V.SetBundlingStrength(float)\nC++: virtual void SetBundlingStrength(double strength)\n\nThe bundling strength for the bundled edges.\n"},
  {"GetBundlingStrength", PyvtkHierarchicalGraphPipeline_GetBundlingStrength, METH_VARARGS,
   "V.GetBundlingStrength() -> float\nC++: virtual double GetBundlingStrength()\n\nThe bundling strength for the bundled edges.\n"},
  {"SetLabelArrayName", PyvtkHierarchicalGraphPipeline_SetLabelArrayName, METH_VARARGS,
   "V.SetLabelArrayName(string)\nC++: virtual void SetLabelArrayName(const char *name)\n\nThe edge label array name.\n"},
  {"GetLabelArrayName", PyvtkHierarchicalGraphPipeline_GetLabelArrayName, METH_VARARGS,
   "V.GetLabelArrayName() -> string\nC++: virtual const char *GetLabelArrayName()\n\nThe edge label array name.\n"},
  {"SetLabelVisibility", PyvtkHierarchicalGraphPipeline_SetLabelVisibility, METH_VARARGS,
   "V.SetLabelVisibility(bool)\nC++: virtual void SetLabelVisibility(bool vis)\n\nThe edge label visibility.\n"},
  {"GetLabelVisibility", PyvtkHierarchicalGraphPipeline_GetLabelVisibility, METH_VARARGS,
   "V.GetLabelVisibility() -> bool\nC++: virtual bool GetLabelVisibility()\n\nThe edge label visibility.\n"},
  {"LabelVisibilityOn", PyvtkHierarchicalGraphPipeline_LabelVisibilityOn, METH_VARARGS,
   "V.LabelVisibilityOn()\nC++: virtual void LabelVisibilityOn()\n\nThe edge label visibility.\n"},
  {"LabelVisibilityOff", PyvtkHierarchicalGraphPipeline_LabelVisibilityOff, METH_VARARGS,
   "V.LabelVisibilityOff()\nC++: virtual void LabelVisibilityOff()\n\nThe edge label visibility.\n"},
  {"SetLabelTextProperty", PyvtkHierarchicalGraphPipeline_SetLabelTextProperty, METH_VARARGS,
   "V.SetLabelTextProperty(vtkTextProperty)\nC++: virtual void SetLabelTextProperty(vtkTextProperty *prop)\n\nThe edge label text property.\n"},
  {"GetLabelTextProperty", PyvtkHierarchicalGraphPipeline_GetLabelTextProperty, METH_VARARGS,
   "V.GetLabelTextProperty() -> vtkTextProperty\nC++: virtual vtkTextProperty *GetLabelTextProperty()\n\nThe edge label text property.\n"},
  {"SetColorArrayName", PyvtkHierarchicalGraphPipeline_SetColorArrayName, METH_VARARGS,
   "V.SetColorArrayName(string)\nC++: virtual void SetColorArrayName(const char *name)\n\nThe edge color array.\n"},
  {"GetColorArrayName", PyvtkHierarchicalGraphPipeline_GetColorArrayName, METH_VARARGS,
   "V.GetColorArrayName() -> string\nC++: virtual const char *GetColorArrayName()\n\nThe edge color array.\n"},
  {"SetColorEdgesByArray", PyvtkHierarchicalGraphPipeline_SetColorEdgesByArray, METH_VARARGS,
   "V.SetColorEdgesByArray(bool)\nC++: virtual void SetColorEdgesByArray(bool vis)\n\nWhether to color the edges by an array.\n"},
  {"GetColorEdgesByArray", PyvtkHierarchicalGraphPipeline_GetColorEdgesByArray, METH_VARARGS,
   "V.GetColorEdgesByArray() -> bool\nC++: virtual bool GetColorEdgesByArray()\n\nWhether to color the edges by an array.\n"},
  {"ColorEdgesByArrayOn", PyvtkHierarchicalGraphPipeline_ColorEdgesByArrayOn, METH_VARARGS,
   "V.ColorEdgesByArrayOn()\nC++: virtual void ColorEdgesByArrayOn()\n\nWhether to color the edges by an array.\n"},
  {"ColorEdgesByArrayOff", PyvtkHierarchicalGraphPipeline_ColorEdgesByArrayOff, METH_VARARGS,
   "V.ColorEdgesByArrayOff()\nC++: virtual void ColorEdgesByArrayOff()\n\nWhether to color the edges by an array.\n"},
  {"SetVisibility", PyvtkHierarchicalGraphPipeline_SetVisibility, METH_VARARGS,
   "V.SetVisibility(bool)\nC++: virtual void SetVisibility(bool vis)\n\nThe visibility of this graph.\n"},
  {"GetVisibility", PyvtkHierarchicalGraphPipeline_GetVisibility, METH_VARARGS,
   "V.GetVisibility() -> bool\nC++: virtual bool GetVisibility()\n\nThe visibility of this graph.\n"},
  {"VisibilityOn", PyvtkHierarchicalGraphPipeline_VisibilityOn, METH_VARARGS,
   "V.VisibilityOn()\nC++: virtual void VisibilityOn()\n\nThe visibility of this graph.\n"},
  {"VisibilityOff", PyvtkHierarchicalGraphPipeline_VisibilityOff, METH_VARARGS,
   "V.VisibilityOff()\nC++: virtual void VisibilityOff()\n\nThe visibility of this graph.\n"},
  {"ConvertSelection", PyvtkHierarchicalGraphPipeline_ConvertSelection, METH_VARARGS,
   "V.ConvertSelection(vtkDataRepresentation, vtkSelection)\n    -> vtkSelection\nC++: virtual vtkSelection *ConvertSelection(\n    vtkDataRepresentation *rep, vtkSelection *sel)\n\nReturns a new selection relevant to this graph based on an input\nselection and the view that this graph is contained in.\n"},
  {"PrepareInputConnections", PyvtkHierarchicalGraphPipeline_PrepareInputConnections, METH_VARARGS,
   "V.PrepareInputConnections(vtkAlgorithmOutput, vtkAlgorithmOutput,\n    vtkAlgorithmOutput)\nC++: virtual void PrepareInputConnections(\n    vtkAlgorithmOutput *graphConn, vtkAlgorithmOutput *treeConn,\n    vtkAlgorithmOutput *annConn)\n\nSets the input connections for this graph. graphConn is the input\ngraph connection. treeConn is the input tree connection. annConn\nis the annotation link connection.\n"},
  {"ApplyViewTheme", PyvtkHierarchicalGraphPipeline_ApplyViewTheme, METH_VARARGS,
   "V.ApplyViewTheme(vtkViewTheme)\nC++: virtual void ApplyViewTheme(vtkViewTheme *theme)\n\nApplies the view theme to this graph.\n"},
  {"SetHoverArrayName", PyvtkHierarchicalGraphPipeline_SetHoverArrayName, METH_VARARGS,
   "V.SetHoverArrayName(string)\nC++: virtual void SetHoverArrayName(const char *_arg)\n\nThe array to use while hovering over an edge.\n"},
  {"GetHoverArrayName", PyvtkHierarchicalGraphPipeline_GetHoverArrayName, METH_VARARGS,
   "V.GetHoverArrayName() -> string\nC++: virtual char *GetHoverArrayName()\n\nThe array to use while hovering over an edge.\n"},
  {"SetSplineType", PyvtkHierarchicalGraphPipeline_SetSplineType, METH_VARARGS,
   "V.SetSplineType(int)\nC++: virtual void SetSplineType(int type)\n\nThe spline mode to use in vtkSplineGraphEdges.\nvtkSplineGraphEdges::CUSTOM uses a vtkCardinalSpline.\nvtkSplineGraphEdges::BSPLINE uses a b-spline. The default is\nBSPLINE.\n"},
  {"GetSplineType", PyvtkHierarchicalGraphPipeline_GetSplineType, METH_VARARGS,
   "V.GetSplineType() -> int\nC++: virtual int GetSplineType()\n\nThe spline mode to use in vtkSplineGraphEdges.\nvtkSplineGraphEdges::CUSTOM uses a vtkCardinalSpline.\nvtkSplineGraphEdges::BSPLINE uses a b-spline. The default is\nBSPLINE.\n"},
  {"RegisterProgress", PyvtkHierarchicalGraphPipeline_RegisterProgress, METH_VARARGS,
   "V.RegisterProgress(vtkRenderView)\nC++: void RegisterProgress(vtkRenderView *view)\n\nRegister progress with a view.\n"},
  {nullptr, nullptr, 0, nullptr}
};

static PyTypeObject PyvtkHierarchicalGraphPipeline_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkViewsInfovisPython.vtkHierarchicalGraphPipeline", // tp_name
  sizeof(PyVTKObject), // tp_basicsize
  0, // tp_itemsize
  PyVTKObject_Delete, // tp_dealloc
  0, // tp_print
  nullptr, // tp_getattr
  nullptr, // tp_setattr
  nullptr, // tp_compare
  PyVTKObject_Repr, // tp_repr
  nullptr, // tp_as_number
  nullptr, // tp_as_sequence
  nullptr, // tp_as_mapping
  nullptr, // tp_hash
  nullptr, // tp_call
  PyVTKObject_String, // tp_str
  PyObject_GenericGetAttr, // tp_getattro
  PyObject_GenericSetAttr, // tp_setattro
  &PyVTKObject_AsBuffer, // tp_as_buffer
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_BASETYPE, // tp_flags
  PyvtkHierarchicalGraphPipeline_Doc, // tp_doc
  PyVTKObject_Traverse, // tp_traverse
  nullptr, // tp_clear
  nullptr, // tp_richcompare
  offsetof(PyVTKObject, vtk_weakreflist), // tp_weaklistoffset
  nullptr, // tp_iter
  nullptr, // tp_iternext
  nullptr, // tp_methods
  nullptr, // tp_members
  PyVTKObject_GetSet, // tp_getset
  nullptr, // tp_base
  nullptr, // tp_dict
  nullptr, // tp_descr_get
  nullptr, // tp_descr_set
  offsetof(PyVTKObject, vtk_dict), // tp_dictoffset
  nullptr, // tp_init
  nullptr, // tp_alloc
  PyVTKObject_New, // tp_new
  PyObject_GC_Del, // tp_free
  nullptr, // tp_is_gc
  nullptr, // tp_bases
  nullptr, // tp_mro
  nullptr, // tp_cache
  nullptr, // tp_subclasses
  nullptr, // tp_weaklist
  VTK_WRAP_PYTHON_SUPPRESS_UNINITIALIZED
};

static vtkObjectBase *PyvtkHierarchicalGraphPipeline_StaticNew()
{
  return vtkHierarchicalGraphPipeline::New();
}

PyObject *PyvtkHierarchicalGraphPipeline_ClassNew()
{
  PyVTKClass_Add(
    &PyvtkHierarchicalGraphPipeline_Type, PyvtkHierarchicalGraphPipeline_Methods,
    "vtkHierarchicalGraphPipeline",
 &PyvtkHierarchicalGraphPipeline_StaticNew);

  PyTypeObject *pytype = &PyvtkHierarchicalGraphPipeline_Type;

  if ((pytype->tp_flags & Py_TPFLAGS_READY) != 0)
  {
    return (PyObject *)pytype;
  }

#if !defined(VTK_PY3K) && PY_VERSION_HEX >= 0x02060000
  pytype->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif

  pytype->tp_base = (PyTypeObject *)PyvtkObject_ClassNew();

  PyType_Ready(pytype);
  return (PyObject *)pytype;
}

void PyVTKAddFile_vtkHierarchicalGraphPipeline(
  PyObject *dict)
{
  PyObject *o;
  o = PyvtkHierarchicalGraphPipeline_ClassNew();

  if (o && PyDict_SetItemString(dict, "vtkHierarchicalGraphPipeline", o) != 0)
  {
    Py_DECREF(o);
  }

}