/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkRenderedRepresentationWrap.h"
#include "vtkRenderedGraphRepresentationWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkGraphLayoutStrategyWrap.h"
#include "vtkEdgeLayoutStrategyWrap.h"
#include "vtkViewThemeWrap.h"
#include "vtkScalarBarWidgetWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkRenderedGraphRepresentationWrap::ptpl;

VtkRenderedGraphRepresentationWrap::VtkRenderedGraphRepresentationWrap()
{ }

VtkRenderedGraphRepresentationWrap::VtkRenderedGraphRepresentationWrap(vtkSmartPointer<vtkRenderedGraphRepresentation> _native)
{ native = _native; }

VtkRenderedGraphRepresentationWrap::~VtkRenderedGraphRepresentationWrap()
{ }

void VtkRenderedGraphRepresentationWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkRenderedGraphRepresentation").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("RenderedGraphRepresentation").ToLocalChecked(), ConstructorGetter);
}

void VtkRenderedGraphRepresentationWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkRenderedGraphRepresentationWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkRenderedRepresentationWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkRenderedRepresentationWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkRenderedGraphRepresentationWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AddEdgeIconType", AddEdgeIconType);
	Nan::SetPrototypeMethod(tpl, "addEdgeIconType", AddEdgeIconType);

	Nan::SetPrototypeMethod(tpl, "AddVertexIconType", AddVertexIconType);
	Nan::SetPrototypeMethod(tpl, "addVertexIconType", AddVertexIconType);

	Nan::SetPrototypeMethod(tpl, "ApplyViewTheme", ApplyViewTheme);
	Nan::SetPrototypeMethod(tpl, "applyViewTheme", ApplyViewTheme);

	Nan::SetPrototypeMethod(tpl, "ClearEdgeIconTypes", ClearEdgeIconTypes);
	Nan::SetPrototypeMethod(tpl, "clearEdgeIconTypes", ClearEdgeIconTypes);

	Nan::SetPrototypeMethod(tpl, "ClearVertexIconTypes", ClearVertexIconTypes);
	Nan::SetPrototypeMethod(tpl, "clearVertexIconTypes", ClearVertexIconTypes);

	Nan::SetPrototypeMethod(tpl, "ColorEdgesByArrayOff", ColorEdgesByArrayOff);
	Nan::SetPrototypeMethod(tpl, "colorEdgesByArrayOff", ColorEdgesByArrayOff);

	Nan::SetPrototypeMethod(tpl, "ColorEdgesByArrayOn", ColorEdgesByArrayOn);
	Nan::SetPrototypeMethod(tpl, "colorEdgesByArrayOn", ColorEdgesByArrayOn);

	Nan::SetPrototypeMethod(tpl, "ColorVerticesByArrayOff", ColorVerticesByArrayOff);
	Nan::SetPrototypeMethod(tpl, "colorVerticesByArrayOff", ColorVerticesByArrayOff);

	Nan::SetPrototypeMethod(tpl, "ColorVerticesByArrayOn", ColorVerticesByArrayOn);
	Nan::SetPrototypeMethod(tpl, "colorVerticesByArrayOn", ColorVerticesByArrayOn);

	Nan::SetPrototypeMethod(tpl, "ComputeSelectedGraphBounds", ComputeSelectedGraphBounds);
	Nan::SetPrototypeMethod(tpl, "computeSelectedGraphBounds", ComputeSelectedGraphBounds);

	Nan::SetPrototypeMethod(tpl, "EdgeIconVisibilityOff", EdgeIconVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "edgeIconVisibilityOff", EdgeIconVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "EdgeIconVisibilityOn", EdgeIconVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "edgeIconVisibilityOn", EdgeIconVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "EdgeLabelVisibilityOff", EdgeLabelVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "edgeLabelVisibilityOff", EdgeLabelVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "EdgeLabelVisibilityOn", EdgeLabelVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "edgeLabelVisibilityOn", EdgeLabelVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "EdgeVisibilityOff", EdgeVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "edgeVisibilityOff", EdgeVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "EdgeVisibilityOn", EdgeVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "edgeVisibilityOn", EdgeVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "EnableEdgesByArrayOff", EnableEdgesByArrayOff);
	Nan::SetPrototypeMethod(tpl, "enableEdgesByArrayOff", EnableEdgesByArrayOff);

	Nan::SetPrototypeMethod(tpl, "EnableEdgesByArrayOn", EnableEdgesByArrayOn);
	Nan::SetPrototypeMethod(tpl, "enableEdgesByArrayOn", EnableEdgesByArrayOn);

	Nan::SetPrototypeMethod(tpl, "EnableVerticesByArrayOff", EnableVerticesByArrayOff);
	Nan::SetPrototypeMethod(tpl, "enableVerticesByArrayOff", EnableVerticesByArrayOff);

	Nan::SetPrototypeMethod(tpl, "EnableVerticesByArrayOn", EnableVerticesByArrayOn);
	Nan::SetPrototypeMethod(tpl, "enableVerticesByArrayOn", EnableVerticesByArrayOn);

	Nan::SetPrototypeMethod(tpl, "GetColorEdgesByArray", GetColorEdgesByArray);
	Nan::SetPrototypeMethod(tpl, "getColorEdgesByArray", GetColorEdgesByArray);

	Nan::SetPrototypeMethod(tpl, "GetColorVerticesByArray", GetColorVerticesByArray);
	Nan::SetPrototypeMethod(tpl, "getColorVerticesByArray", GetColorVerticesByArray);

	Nan::SetPrototypeMethod(tpl, "GetEdgeColorArrayName", GetEdgeColorArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeColorArrayName", GetEdgeColorArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeHoverArrayName", GetEdgeHoverArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeHoverArrayName", GetEdgeHoverArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeIconAlignment", GetEdgeIconAlignment);
	Nan::SetPrototypeMethod(tpl, "getEdgeIconAlignment", GetEdgeIconAlignment);

	Nan::SetPrototypeMethod(tpl, "GetEdgeIconArrayName", GetEdgeIconArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeIconArrayName", GetEdgeIconArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeIconPriorityArrayName", GetEdgeIconPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeIconPriorityArrayName", GetEdgeIconPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeIconVisibility", GetEdgeIconVisibility);
	Nan::SetPrototypeMethod(tpl, "getEdgeIconVisibility", GetEdgeIconVisibility);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLabelArrayName", GetEdgeLabelArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeLabelArrayName", GetEdgeLabelArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLabelPriorityArrayName", GetEdgeLabelPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeLabelPriorityArrayName", GetEdgeLabelPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLabelTextProperty", GetEdgeLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getEdgeLabelTextProperty", GetEdgeLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLabelVisibility", GetEdgeLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "getEdgeLabelVisibility", GetEdgeLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLayoutStrategy", GetEdgeLayoutStrategy);
	Nan::SetPrototypeMethod(tpl, "getEdgeLayoutStrategy", GetEdgeLayoutStrategy);

	Nan::SetPrototypeMethod(tpl, "GetEdgeLayoutStrategyName", GetEdgeLayoutStrategyName);
	Nan::SetPrototypeMethod(tpl, "getEdgeLayoutStrategyName", GetEdgeLayoutStrategyName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeScalarBar", GetEdgeScalarBar);
	Nan::SetPrototypeMethod(tpl, "getEdgeScalarBar", GetEdgeScalarBar);

	Nan::SetPrototypeMethod(tpl, "GetEdgeScalarBarVisibility", GetEdgeScalarBarVisibility);
	Nan::SetPrototypeMethod(tpl, "getEdgeScalarBarVisibility", GetEdgeScalarBarVisibility);

	Nan::SetPrototypeMethod(tpl, "GetEdgeSelection", GetEdgeSelection);
	Nan::SetPrototypeMethod(tpl, "getEdgeSelection", GetEdgeSelection);

	Nan::SetPrototypeMethod(tpl, "GetEdgeVisibility", GetEdgeVisibility);
	Nan::SetPrototypeMethod(tpl, "getEdgeVisibility", GetEdgeVisibility);

	Nan::SetPrototypeMethod(tpl, "GetEnableEdgesByArray", GetEnableEdgesByArray);
	Nan::SetPrototypeMethod(tpl, "getEnableEdgesByArray", GetEnableEdgesByArray);

	Nan::SetPrototypeMethod(tpl, "GetEnableVerticesByArray", GetEnableVerticesByArray);
	Nan::SetPrototypeMethod(tpl, "getEnableVerticesByArray", GetEnableVerticesByArray);

	Nan::SetPrototypeMethod(tpl, "GetEnabledEdgesArrayName", GetEnabledEdgesArrayName);
	Nan::SetPrototypeMethod(tpl, "getEnabledEdgesArrayName", GetEnabledEdgesArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEnabledVerticesArrayName", GetEnabledVerticesArrayName);
	Nan::SetPrototypeMethod(tpl, "getEnabledVerticesArrayName", GetEnabledVerticesArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlyphType", GetGlyphType);
	Nan::SetPrototypeMethod(tpl, "getGlyphType", GetGlyphType);

	Nan::SetPrototypeMethod(tpl, "GetHideEdgeLabelsOnInteraction", GetHideEdgeLabelsOnInteraction);
	Nan::SetPrototypeMethod(tpl, "getHideEdgeLabelsOnInteraction", GetHideEdgeLabelsOnInteraction);

	Nan::SetPrototypeMethod(tpl, "GetHideVertexLabelsOnInteraction", GetHideVertexLabelsOnInteraction);
	Nan::SetPrototypeMethod(tpl, "getHideVertexLabelsOnInteraction", GetHideVertexLabelsOnInteraction);

	Nan::SetPrototypeMethod(tpl, "GetLayoutStrategy", GetLayoutStrategy);
	Nan::SetPrototypeMethod(tpl, "getLayoutStrategy", GetLayoutStrategy);

	Nan::SetPrototypeMethod(tpl, "GetLayoutStrategyName", GetLayoutStrategyName);
	Nan::SetPrototypeMethod(tpl, "getLayoutStrategyName", GetLayoutStrategyName);

	Nan::SetPrototypeMethod(tpl, "GetScaling", GetScaling);
	Nan::SetPrototypeMethod(tpl, "getScaling", GetScaling);

	Nan::SetPrototypeMethod(tpl, "GetScalingArrayName", GetScalingArrayName);
	Nan::SetPrototypeMethod(tpl, "getScalingArrayName", GetScalingArrayName);

	Nan::SetPrototypeMethod(tpl, "GetUseEdgeIconTypeMap", GetUseEdgeIconTypeMap);
	Nan::SetPrototypeMethod(tpl, "getUseEdgeIconTypeMap", GetUseEdgeIconTypeMap);

	Nan::SetPrototypeMethod(tpl, "GetUseVertexIconTypeMap", GetUseVertexIconTypeMap);
	Nan::SetPrototypeMethod(tpl, "getUseVertexIconTypeMap", GetUseVertexIconTypeMap);

	Nan::SetPrototypeMethod(tpl, "GetVertexColorArrayName", GetVertexColorArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexColorArrayName", GetVertexColorArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexDefaultIcon", GetVertexDefaultIcon);
	Nan::SetPrototypeMethod(tpl, "getVertexDefaultIcon", GetVertexDefaultIcon);

	Nan::SetPrototypeMethod(tpl, "GetVertexHoverArrayName", GetVertexHoverArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexHoverArrayName", GetVertexHoverArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexIconAlignment", GetVertexIconAlignment);
	Nan::SetPrototypeMethod(tpl, "getVertexIconAlignment", GetVertexIconAlignment);

	Nan::SetPrototypeMethod(tpl, "GetVertexIconArrayName", GetVertexIconArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexIconArrayName", GetVertexIconArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexIconPriorityArrayName", GetVertexIconPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexIconPriorityArrayName", GetVertexIconPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexIconSelectionMode", GetVertexIconSelectionMode);
	Nan::SetPrototypeMethod(tpl, "getVertexIconSelectionMode", GetVertexIconSelectionMode);

	Nan::SetPrototypeMethod(tpl, "GetVertexIconVisibility", GetVertexIconVisibility);
	Nan::SetPrototypeMethod(tpl, "getVertexIconVisibility", GetVertexIconVisibility);

	Nan::SetPrototypeMethod(tpl, "GetVertexLabelArrayName", GetVertexLabelArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexLabelArrayName", GetVertexLabelArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexLabelPriorityArrayName", GetVertexLabelPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "getVertexLabelPriorityArrayName", GetVertexLabelPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "GetVertexLabelTextProperty", GetVertexLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getVertexLabelTextProperty", GetVertexLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetVertexLabelVisibility", GetVertexLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "getVertexLabelVisibility", GetVertexLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "GetVertexScalarBar", GetVertexScalarBar);
	Nan::SetPrototypeMethod(tpl, "getVertexScalarBar", GetVertexScalarBar);

	Nan::SetPrototypeMethod(tpl, "GetVertexScalarBarVisibility", GetVertexScalarBarVisibility);
	Nan::SetPrototypeMethod(tpl, "getVertexScalarBarVisibility", GetVertexScalarBarVisibility);

	Nan::SetPrototypeMethod(tpl, "GetVertexSelectedIcon", GetVertexSelectedIcon);
	Nan::SetPrototypeMethod(tpl, "getVertexSelectedIcon", GetVertexSelectedIcon);

	Nan::SetPrototypeMethod(tpl, "HideEdgeLabelsOnInteractionOff", HideEdgeLabelsOnInteractionOff);
	Nan::SetPrototypeMethod(tpl, "hideEdgeLabelsOnInteractionOff", HideEdgeLabelsOnInteractionOff);

	Nan::SetPrototypeMethod(tpl, "HideEdgeLabelsOnInteractionOn", HideEdgeLabelsOnInteractionOn);
	Nan::SetPrototypeMethod(tpl, "hideEdgeLabelsOnInteractionOn", HideEdgeLabelsOnInteractionOn);

	Nan::SetPrototypeMethod(tpl, "HideVertexLabelsOnInteractionOff", HideVertexLabelsOnInteractionOff);
	Nan::SetPrototypeMethod(tpl, "hideVertexLabelsOnInteractionOff", HideVertexLabelsOnInteractionOff);

	Nan::SetPrototypeMethod(tpl, "HideVertexLabelsOnInteractionOn", HideVertexLabelsOnInteractionOn);
	Nan::SetPrototypeMethod(tpl, "hideVertexLabelsOnInteractionOn", HideVertexLabelsOnInteractionOn);

	Nan::SetPrototypeMethod(tpl, "IsLayoutComplete", IsLayoutComplete);
	Nan::SetPrototypeMethod(tpl, "isLayoutComplete", IsLayoutComplete);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "ScalingOff", ScalingOff);
	Nan::SetPrototypeMethod(tpl, "scalingOff", ScalingOff);

	Nan::SetPrototypeMethod(tpl, "ScalingOn", ScalingOn);
	Nan::SetPrototypeMethod(tpl, "scalingOn", ScalingOn);

	Nan::SetPrototypeMethod(tpl, "SetColorEdgesByArray", SetColorEdgesByArray);
	Nan::SetPrototypeMethod(tpl, "setColorEdgesByArray", SetColorEdgesByArray);

	Nan::SetPrototypeMethod(tpl, "SetColorVerticesByArray", SetColorVerticesByArray);
	Nan::SetPrototypeMethod(tpl, "setColorVerticesByArray", SetColorVerticesByArray);

	Nan::SetPrototypeMethod(tpl, "SetEdgeColorArrayName", SetEdgeColorArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeColorArrayName", SetEdgeColorArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeHoverArrayName", SetEdgeHoverArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeHoverArrayName", SetEdgeHoverArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeIconAlignment", SetEdgeIconAlignment);
	Nan::SetPrototypeMethod(tpl, "setEdgeIconAlignment", SetEdgeIconAlignment);

	Nan::SetPrototypeMethod(tpl, "SetEdgeIconArrayName", SetEdgeIconArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeIconArrayName", SetEdgeIconArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeIconPriorityArrayName", SetEdgeIconPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeIconPriorityArrayName", SetEdgeIconPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeIconVisibility", SetEdgeIconVisibility);
	Nan::SetPrototypeMethod(tpl, "setEdgeIconVisibility", SetEdgeIconVisibility);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLabelArrayName", SetEdgeLabelArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeLabelArrayName", SetEdgeLabelArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLabelPriorityArrayName", SetEdgeLabelPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "setEdgeLabelPriorityArrayName", SetEdgeLabelPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLabelTextProperty", SetEdgeLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setEdgeLabelTextProperty", SetEdgeLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLabelVisibility", SetEdgeLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "setEdgeLabelVisibility", SetEdgeLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLayoutStrategy", SetEdgeLayoutStrategy);
	Nan::SetPrototypeMethod(tpl, "setEdgeLayoutStrategy", SetEdgeLayoutStrategy);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLayoutStrategyToArcParallel", SetEdgeLayoutStrategyToArcParallel);
	Nan::SetPrototypeMethod(tpl, "setEdgeLayoutStrategyToArcParallel", SetEdgeLayoutStrategyToArcParallel);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLayoutStrategyToGeo", SetEdgeLayoutStrategyToGeo);
	Nan::SetPrototypeMethod(tpl, "setEdgeLayoutStrategyToGeo", SetEdgeLayoutStrategyToGeo);

	Nan::SetPrototypeMethod(tpl, "SetEdgeLayoutStrategyToPassThrough", SetEdgeLayoutStrategyToPassThrough);
	Nan::SetPrototypeMethod(tpl, "setEdgeLayoutStrategyToPassThrough", SetEdgeLayoutStrategyToPassThrough);

	Nan::SetPrototypeMethod(tpl, "SetEdgeScalarBarVisibility", SetEdgeScalarBarVisibility);
	Nan::SetPrototypeMethod(tpl, "setEdgeScalarBarVisibility", SetEdgeScalarBarVisibility);

	Nan::SetPrototypeMethod(tpl, "SetEdgeSelection", SetEdgeSelection);
	Nan::SetPrototypeMethod(tpl, "setEdgeSelection", SetEdgeSelection);

	Nan::SetPrototypeMethod(tpl, "SetEdgeVisibility", SetEdgeVisibility);
	Nan::SetPrototypeMethod(tpl, "setEdgeVisibility", SetEdgeVisibility);

	Nan::SetPrototypeMethod(tpl, "SetEnableEdgesByArray", SetEnableEdgesByArray);
	Nan::SetPrototypeMethod(tpl, "setEnableEdgesByArray", SetEnableEdgesByArray);

	Nan::SetPrototypeMethod(tpl, "SetEnableVerticesByArray", SetEnableVerticesByArray);
	Nan::SetPrototypeMethod(tpl, "setEnableVerticesByArray", SetEnableVerticesByArray);

	Nan::SetPrototypeMethod(tpl, "SetEnabledEdgesArrayName", SetEnabledEdgesArrayName);
	Nan::SetPrototypeMethod(tpl, "setEnabledEdgesArrayName", SetEnabledEdgesArrayName);

	Nan::SetPrototypeMethod(tpl, "SetEnabledVerticesArrayName", SetEnabledVerticesArrayName);
	Nan::SetPrototypeMethod(tpl, "setEnabledVerticesArrayName", SetEnabledVerticesArrayName);

	Nan::SetPrototypeMethod(tpl, "SetGlyphType", SetGlyphType);
	Nan::SetPrototypeMethod(tpl, "setGlyphType", SetGlyphType);

	Nan::SetPrototypeMethod(tpl, "SetHideEdgeLabelsOnInteraction", SetHideEdgeLabelsOnInteraction);
	Nan::SetPrototypeMethod(tpl, "setHideEdgeLabelsOnInteraction", SetHideEdgeLabelsOnInteraction);

	Nan::SetPrototypeMethod(tpl, "SetHideVertexLabelsOnInteraction", SetHideVertexLabelsOnInteraction);
	Nan::SetPrototypeMethod(tpl, "setHideVertexLabelsOnInteraction", SetHideVertexLabelsOnInteraction);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategy", SetLayoutStrategy);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategy", SetLayoutStrategy);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToAssignCoordinates", SetLayoutStrategyToAssignCoordinates);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToAssignCoordinates", SetLayoutStrategyToAssignCoordinates);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToCircular", SetLayoutStrategyToCircular);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToCircular", SetLayoutStrategyToCircular);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToClustering2D", SetLayoutStrategyToClustering2D);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToClustering2D", SetLayoutStrategyToClustering2D);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToCommunity2D", SetLayoutStrategyToCommunity2D);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToCommunity2D", SetLayoutStrategyToCommunity2D);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToCone", SetLayoutStrategyToCone);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToCone", SetLayoutStrategyToCone);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToCosmicTree", SetLayoutStrategyToCosmicTree);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToCosmicTree", SetLayoutStrategyToCosmicTree);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToFast2D", SetLayoutStrategyToFast2D);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToFast2D", SetLayoutStrategyToFast2D);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToForceDirected", SetLayoutStrategyToForceDirected);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToForceDirected", SetLayoutStrategyToForceDirected);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToPassThrough", SetLayoutStrategyToPassThrough);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToPassThrough", SetLayoutStrategyToPassThrough);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToRandom", SetLayoutStrategyToRandom);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToRandom", SetLayoutStrategyToRandom);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToSimple2D", SetLayoutStrategyToSimple2D);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToSimple2D", SetLayoutStrategyToSimple2D);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToSpanTree", SetLayoutStrategyToSpanTree);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToSpanTree", SetLayoutStrategyToSpanTree);

	Nan::SetPrototypeMethod(tpl, "SetLayoutStrategyToTree", SetLayoutStrategyToTree);
	Nan::SetPrototypeMethod(tpl, "setLayoutStrategyToTree", SetLayoutStrategyToTree);

	Nan::SetPrototypeMethod(tpl, "SetScaling", SetScaling);
	Nan::SetPrototypeMethod(tpl, "setScaling", SetScaling);

	Nan::SetPrototypeMethod(tpl, "SetScalingArrayName", SetScalingArrayName);
	Nan::SetPrototypeMethod(tpl, "setScalingArrayName", SetScalingArrayName);

	Nan::SetPrototypeMethod(tpl, "SetUseEdgeIconTypeMap", SetUseEdgeIconTypeMap);
	Nan::SetPrototypeMethod(tpl, "setUseEdgeIconTypeMap", SetUseEdgeIconTypeMap);

	Nan::SetPrototypeMethod(tpl, "SetUseVertexIconTypeMap", SetUseVertexIconTypeMap);
	Nan::SetPrototypeMethod(tpl, "setUseVertexIconTypeMap", SetUseVertexIconTypeMap);

	Nan::SetPrototypeMethod(tpl, "SetVertexColorArrayName", SetVertexColorArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexColorArrayName", SetVertexColorArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexDefaultIcon", SetVertexDefaultIcon);
	Nan::SetPrototypeMethod(tpl, "setVertexDefaultIcon", SetVertexDefaultIcon);

	Nan::SetPrototypeMethod(tpl, "SetVertexHoverArrayName", SetVertexHoverArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexHoverArrayName", SetVertexHoverArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconAlignment", SetVertexIconAlignment);
	Nan::SetPrototypeMethod(tpl, "setVertexIconAlignment", SetVertexIconAlignment);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconArrayName", SetVertexIconArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexIconArrayName", SetVertexIconArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconPriorityArrayName", SetVertexIconPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexIconPriorityArrayName", SetVertexIconPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconSelectionMode", SetVertexIconSelectionMode);
	Nan::SetPrototypeMethod(tpl, "setVertexIconSelectionMode", SetVertexIconSelectionMode);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconSelectionModeToAnnotationIcon", SetVertexIconSelectionModeToAnnotationIcon);
	Nan::SetPrototypeMethod(tpl, "setVertexIconSelectionModeToAnnotationIcon", SetVertexIconSelectionModeToAnnotationIcon);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconSelectionModeToIgnoreSelection", SetVertexIconSelectionModeToIgnoreSelection);
	Nan::SetPrototypeMethod(tpl, "setVertexIconSelectionModeToIgnoreSelection", SetVertexIconSelectionModeToIgnoreSelection);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconSelectionModeToSelectedIcon", SetVertexIconSelectionModeToSelectedIcon);
	Nan::SetPrototypeMethod(tpl, "setVertexIconSelectionModeToSelectedIcon", SetVertexIconSelectionModeToSelectedIcon);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconSelectionModeToSelectedOffset", SetVertexIconSelectionModeToSelectedOffset);
	Nan::SetPrototypeMethod(tpl, "setVertexIconSelectionModeToSelectedOffset", SetVertexIconSelectionModeToSelectedOffset);

	Nan::SetPrototypeMethod(tpl, "SetVertexIconVisibility", SetVertexIconVisibility);
	Nan::SetPrototypeMethod(tpl, "setVertexIconVisibility", SetVertexIconVisibility);

	Nan::SetPrototypeMethod(tpl, "SetVertexLabelArrayName", SetVertexLabelArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexLabelArrayName", SetVertexLabelArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexLabelPriorityArrayName", SetVertexLabelPriorityArrayName);
	Nan::SetPrototypeMethod(tpl, "setVertexLabelPriorityArrayName", SetVertexLabelPriorityArrayName);

	Nan::SetPrototypeMethod(tpl, "SetVertexLabelTextProperty", SetVertexLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setVertexLabelTextProperty", SetVertexLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetVertexLabelVisibility", SetVertexLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "setVertexLabelVisibility", SetVertexLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "SetVertexScalarBarVisibility", SetVertexScalarBarVisibility);
	Nan::SetPrototypeMethod(tpl, "setVertexScalarBarVisibility", SetVertexScalarBarVisibility);

	Nan::SetPrototypeMethod(tpl, "SetVertexSelectedIcon", SetVertexSelectedIcon);
	Nan::SetPrototypeMethod(tpl, "setVertexSelectedIcon", SetVertexSelectedIcon);

	Nan::SetPrototypeMethod(tpl, "UpdateLayout", UpdateLayout);
	Nan::SetPrototypeMethod(tpl, "updateLayout", UpdateLayout);

	Nan::SetPrototypeMethod(tpl, "UseEdgeIconTypeMapOff", UseEdgeIconTypeMapOff);
	Nan::SetPrototypeMethod(tpl, "useEdgeIconTypeMapOff", UseEdgeIconTypeMapOff);

	Nan::SetPrototypeMethod(tpl, "UseEdgeIconTypeMapOn", UseEdgeIconTypeMapOn);
	Nan::SetPrototypeMethod(tpl, "useEdgeIconTypeMapOn", UseEdgeIconTypeMapOn);

	Nan::SetPrototypeMethod(tpl, "UseVertexIconTypeMapOff", UseVertexIconTypeMapOff);
	Nan::SetPrototypeMethod(tpl, "useVertexIconTypeMapOff", UseVertexIconTypeMapOff);

	Nan::SetPrototypeMethod(tpl, "UseVertexIconTypeMapOn", UseVertexIconTypeMapOn);
	Nan::SetPrototypeMethod(tpl, "useVertexIconTypeMapOn", UseVertexIconTypeMapOn);

	Nan::SetPrototypeMethod(tpl, "VertexIconVisibilityOff", VertexIconVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "vertexIconVisibilityOff", VertexIconVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "VertexIconVisibilityOn", VertexIconVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "vertexIconVisibilityOn", VertexIconVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "VertexLabelVisibilityOff", VertexLabelVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "vertexLabelVisibilityOff", VertexLabelVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "VertexLabelVisibilityOn", VertexLabelVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "vertexLabelVisibilityOn", VertexLabelVisibilityOn);

#ifdef VTK_NODE_PLUS_VTKRENDEREDGRAPHREPRESENTATIONWRAP_INITPTPL
	VTK_NODE_PLUS_VTKRENDEREDGRAPHREPRESENTATIONWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkRenderedGraphRepresentationWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkRenderedGraphRepresentation> native = vtkSmartPointer<vtkRenderedGraphRepresentation>::New();
		VtkRenderedGraphRepresentationWrap* obj = new VtkRenderedGraphRepresentationWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkRenderedGraphRepresentationWrap::AddEdgeIconType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->AddEdgeIconType(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::AddVertexIconType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->AddVertexIconType(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::ApplyViewTheme(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewThemeWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewThemeWrap *a0 = ObjectWrap::Unwrap<VtkViewThemeWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ApplyViewTheme(
			(vtkViewTheme *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::ClearEdgeIconTypes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ClearEdgeIconTypes();
}

void VtkRenderedGraphRepresentationWrap::ClearVertexIconTypes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ClearVertexIconTypes();
}

void VtkRenderedGraphRepresentationWrap::ColorEdgesByArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ColorEdgesByArrayOff();
}

void VtkRenderedGraphRepresentationWrap::ColorEdgesByArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ColorEdgesByArrayOn();
}

void VtkRenderedGraphRepresentationWrap::ColorVerticesByArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ColorVerticesByArrayOff();
}

void VtkRenderedGraphRepresentationWrap::ColorVerticesByArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ColorVerticesByArrayOn();
}

void VtkRenderedGraphRepresentationWrap::ComputeSelectedGraphBounds(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ComputeSelectedGraphBounds(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[6];
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ComputeSelectedGraphBounds(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::EdgeIconVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeIconVisibilityOff();
}

void VtkRenderedGraphRepresentationWrap::EdgeIconVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeIconVisibilityOn();
}

void VtkRenderedGraphRepresentationWrap::EdgeLabelVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeLabelVisibilityOff();
}

void VtkRenderedGraphRepresentationWrap::EdgeLabelVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeLabelVisibilityOn();
}

void VtkRenderedGraphRepresentationWrap::EdgeVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeVisibilityOff();
}

void VtkRenderedGraphRepresentationWrap::EdgeVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EdgeVisibilityOn();
}

void VtkRenderedGraphRepresentationWrap::EnableEdgesByArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EnableEdgesByArrayOff();
}

void VtkRenderedGraphRepresentationWrap::EnableEdgesByArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EnableEdgesByArrayOn();
}

void VtkRenderedGraphRepresentationWrap::EnableVerticesByArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EnableVerticesByArrayOff();
}

void VtkRenderedGraphRepresentationWrap::EnableVerticesByArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EnableVerticesByArrayOn();
}

void VtkRenderedGraphRepresentationWrap::GetColorEdgesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetColorEdgesByArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetColorVerticesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetColorVerticesByArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeColorArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeColorArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeHoverArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeHoverArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeIconAlignment(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeIconAlignment();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeIconArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeIconArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeIconPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeIconPriorityArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeIconVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeIconVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLabelArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLabelArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLabelPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLabelPriorityArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkTextProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLabelTextProperty();
	VtkTextPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkTextPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkTextPropertyWrap *w = new VtkTextPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLabelVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLayoutStrategy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkEdgeLayoutStrategy * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLayoutStrategy();
	VtkEdgeLayoutStrategyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkEdgeLayoutStrategyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkEdgeLayoutStrategyWrap *w = new VtkEdgeLayoutStrategyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetEdgeLayoutStrategyName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeLayoutStrategyName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEdgeScalarBar(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkScalarBarWidget * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeScalarBar();
	VtkScalarBarWidgetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkScalarBarWidgetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkScalarBarWidgetWrap *w = new VtkScalarBarWidgetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetEdgeScalarBarVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeScalarBarVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeSelection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeSelection();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEdgeVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEdgeVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEnableEdgesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEnableEdgesByArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEnableVerticesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEnableVerticesByArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetEnabledEdgesArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEnabledEdgesArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetEnabledVerticesArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetEnabledVerticesArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetGlyphType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlyphType();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetHideEdgeLabelsOnInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHideEdgeLabelsOnInteraction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetHideVertexLabelsOnInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHideVertexLabelsOnInteraction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetLayoutStrategy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkGraphLayoutStrategy * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLayoutStrategy();
	VtkGraphLayoutStrategyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkGraphLayoutStrategyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkGraphLayoutStrategyWrap *w = new VtkGraphLayoutStrategyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetLayoutStrategyName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLayoutStrategyName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetScaling(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetScaling();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetScalingArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetScalingArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetUseEdgeIconTypeMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetUseEdgeIconTypeMap();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetUseVertexIconTypeMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetUseVertexIconTypeMap();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexColorArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexColorArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexDefaultIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexDefaultIcon();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexHoverArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexHoverArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexIconAlignment(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexIconAlignment();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexIconArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexIconArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexIconPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexIconPriorityArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexIconSelectionMode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexIconSelectionMode();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexIconVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexIconVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexLabelArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexLabelArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexLabelPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexLabelPriorityArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkRenderedGraphRepresentationWrap::GetVertexLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkTextProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexLabelTextProperty();
	VtkTextPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkTextPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkTextPropertyWrap *w = new VtkTextPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetVertexLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexLabelVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexScalarBar(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkScalarBarWidget * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexScalarBar();
	VtkScalarBarWidgetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkScalarBarWidgetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkScalarBarWidgetWrap *w = new VtkScalarBarWidgetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::GetVertexScalarBarVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexScalarBarVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::GetVertexSelectedIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVertexSelectedIcon();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::HideEdgeLabelsOnInteractionOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HideEdgeLabelsOnInteractionOff();
}

void VtkRenderedGraphRepresentationWrap::HideEdgeLabelsOnInteractionOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HideEdgeLabelsOnInteractionOn();
}

void VtkRenderedGraphRepresentationWrap::HideVertexLabelsOnInteractionOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HideVertexLabelsOnInteractionOff();
}

void VtkRenderedGraphRepresentationWrap::HideVertexLabelsOnInteractionOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HideVertexLabelsOnInteractionOn();
}

void VtkRenderedGraphRepresentationWrap::IsLayoutComplete(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->IsLayoutComplete();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkRenderedGraphRepresentationWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	vtkRenderedGraphRepresentation * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkRenderedGraphRepresentationWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkRenderedGraphRepresentationWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkRenderedGraphRepresentationWrap *w = new VtkRenderedGraphRepresentationWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkRenderedGraphRepresentationWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkRenderedGraphRepresentation * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkRenderedGraphRepresentationWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkRenderedGraphRepresentationWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkRenderedGraphRepresentationWrap *w = new VtkRenderedGraphRepresentationWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::ScalingOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ScalingOff();
}

void VtkRenderedGraphRepresentationWrap::ScalingOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ScalingOn();
}

void VtkRenderedGraphRepresentationWrap::SetColorEdgesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetColorEdgesByArray(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetColorVerticesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetColorVerticesByArray(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeColorArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeColorArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeHoverArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeHoverArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeIconAlignment(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeIconAlignment(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeIconArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeIconArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeIconPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeIconPriorityArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeIconVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeIconVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLabelArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLabelArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLabelPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLabelPriorityArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkTextPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkTextPropertyWrap *a0 = ObjectWrap::Unwrap<VtkTextPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLabelTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLabelVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLayoutStrategy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLayoutStrategy(
			*a0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkEdgeLayoutStrategyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkEdgeLayoutStrategyWrap *a0 = ObjectWrap::Unwrap<VtkEdgeLayoutStrategyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLayoutStrategy(
			(vtkEdgeLayoutStrategy *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLayoutStrategyToArcParallel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetEdgeLayoutStrategyToArcParallel();
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLayoutStrategyToGeo(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeLayoutStrategyToGeo(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeLayoutStrategyToPassThrough(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetEdgeLayoutStrategyToPassThrough();
}

void VtkRenderedGraphRepresentationWrap::SetEdgeScalarBarVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeScalarBarVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeSelection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeSelection(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEdgeVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEdgeVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEnableEdgesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnableEdgesByArray(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEnableVerticesByArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnableVerticesByArray(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEnabledEdgesArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnabledEdgesArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetEnabledVerticesArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnabledVerticesArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetGlyphType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGlyphType(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetHideEdgeLabelsOnInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetHideEdgeLabelsOnInteraction(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetHideVertexLabelsOnInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetHideVertexLabelsOnInteraction(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLayoutStrategy(
			*a0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkGraphLayoutStrategyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkGraphLayoutStrategyWrap *a0 = ObjectWrap::Unwrap<VtkGraphLayoutStrategyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLayoutStrategy(
			(vtkGraphLayoutStrategy *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToAssignCoordinates(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetLayoutStrategyToAssignCoordinates(
					*a0,
					*a1,
					*a2
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToCircular(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToCircular();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToClustering2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToClustering2D();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToCommunity2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToCommunity2D();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToCone(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToCone();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToCosmicTree(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToCosmicTree();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToFast2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToFast2D();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToForceDirected(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToForceDirected();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToPassThrough(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToPassThrough();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToRandom(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToRandom();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToSimple2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToSimple2D();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToSpanTree(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToSpanTree();
}

void VtkRenderedGraphRepresentationWrap::SetLayoutStrategyToTree(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetLayoutStrategyToTree(
						info[0]->BooleanValue(),
						info[1]->NumberValue(),
						info[2]->NumberValue(),
						info[3]->NumberValue()
					);
					return;
				}
			}
		}
	}
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetLayoutStrategyToTree();
}

void VtkRenderedGraphRepresentationWrap::SetScaling(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetScaling(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetScalingArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetScalingArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetUseEdgeIconTypeMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUseEdgeIconTypeMap(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetUseVertexIconTypeMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUseVertexIconTypeMap(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexColorArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexColorArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexDefaultIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexDefaultIcon(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexHoverArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexHoverArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconAlignment(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexIconAlignment(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexIconArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexIconPriorityArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconSelectionMode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexIconSelectionMode(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconSelectionModeToAnnotationIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetVertexIconSelectionModeToAnnotationIcon();
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconSelectionModeToIgnoreSelection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetVertexIconSelectionModeToIgnoreSelection();
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconSelectionModeToSelectedIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetVertexIconSelectionModeToSelectedIcon();
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconSelectionModeToSelectedOffset(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetVertexIconSelectionModeToSelectedOffset();
}

void VtkRenderedGraphRepresentationWrap::SetVertexIconVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexIconVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexLabelArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexLabelArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexLabelPriorityArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexLabelPriorityArrayName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkTextPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkTextPropertyWrap *a0 = ObjectWrap::Unwrap<VtkTextPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexLabelTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexLabelVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexScalarBarVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexScalarBarVisibility(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::SetVertexSelectedIcon(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVertexSelectedIcon(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderedGraphRepresentationWrap::UpdateLayout(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UpdateLayout();
}

void VtkRenderedGraphRepresentationWrap::UseEdgeIconTypeMapOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseEdgeIconTypeMapOff();
}

void VtkRenderedGraphRepresentationWrap::UseEdgeIconTypeMapOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseEdgeIconTypeMapOn();
}

void VtkRenderedGraphRepresentationWrap::UseVertexIconTypeMapOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseVertexIconTypeMapOff();
}

void VtkRenderedGraphRepresentationWrap::UseVertexIconTypeMapOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseVertexIconTypeMapOn();
}

void VtkRenderedGraphRepresentationWrap::VertexIconVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->VertexIconVisibilityOff();
}

void VtkRenderedGraphRepresentationWrap::VertexIconVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->VertexIconVisibilityOn();
}

void VtkRenderedGraphRepresentationWrap::VertexLabelVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->VertexLabelVisibilityOff();
}

void VtkRenderedGraphRepresentationWrap::VertexLabelVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderedGraphRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkRenderedGraphRepresentationWrap>(info.Holder());
	vtkRenderedGraphRepresentation *native = (vtkRenderedGraphRepresentation *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->VertexLabelVisibilityOn();
}