/* 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 "vtkActor2DWrap.h"
#include "vtkLeaderActor2DWrap.h"
#include "vtkObjectWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkViewportWrap.h"
#include "vtkWindowWrap.h"
#include "vtkPropWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkLeaderActor2DWrap::VtkLeaderActor2DWrap()
{ }

VtkLeaderActor2DWrap::VtkLeaderActor2DWrap(vtkSmartPointer<vtkLeaderActor2D> _native)
{ native = _native; }

VtkLeaderActor2DWrap::~VtkLeaderActor2DWrap()
{ }

void VtkLeaderActor2DWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkLeaderActor2D").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("LeaderActor2D").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AutoLabelOff", AutoLabelOff);
	Nan::SetPrototypeMethod(tpl, "autoLabelOff", AutoLabelOff);

	Nan::SetPrototypeMethod(tpl, "AutoLabelOn", AutoLabelOn);
	Nan::SetPrototypeMethod(tpl, "autoLabelOn", AutoLabelOn);

	Nan::SetPrototypeMethod(tpl, "GetAngle", GetAngle);
	Nan::SetPrototypeMethod(tpl, "getAngle", GetAngle);

	Nan::SetPrototypeMethod(tpl, "GetArrowLength", GetArrowLength);
	Nan::SetPrototypeMethod(tpl, "getArrowLength", GetArrowLength);

	Nan::SetPrototypeMethod(tpl, "GetArrowLengthMaxValue", GetArrowLengthMaxValue);
	Nan::SetPrototypeMethod(tpl, "getArrowLengthMaxValue", GetArrowLengthMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowLengthMinValue", GetArrowLengthMinValue);
	Nan::SetPrototypeMethod(tpl, "getArrowLengthMinValue", GetArrowLengthMinValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowPlacement", GetArrowPlacement);
	Nan::SetPrototypeMethod(tpl, "getArrowPlacement", GetArrowPlacement);

	Nan::SetPrototypeMethod(tpl, "GetArrowPlacementMaxValue", GetArrowPlacementMaxValue);
	Nan::SetPrototypeMethod(tpl, "getArrowPlacementMaxValue", GetArrowPlacementMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowPlacementMinValue", GetArrowPlacementMinValue);
	Nan::SetPrototypeMethod(tpl, "getArrowPlacementMinValue", GetArrowPlacementMinValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowStyle", GetArrowStyle);
	Nan::SetPrototypeMethod(tpl, "getArrowStyle", GetArrowStyle);

	Nan::SetPrototypeMethod(tpl, "GetArrowStyleMaxValue", GetArrowStyleMaxValue);
	Nan::SetPrototypeMethod(tpl, "getArrowStyleMaxValue", GetArrowStyleMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowStyleMinValue", GetArrowStyleMinValue);
	Nan::SetPrototypeMethod(tpl, "getArrowStyleMinValue", GetArrowStyleMinValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowWidth", GetArrowWidth);
	Nan::SetPrototypeMethod(tpl, "getArrowWidth", GetArrowWidth);

	Nan::SetPrototypeMethod(tpl, "GetArrowWidthMaxValue", GetArrowWidthMaxValue);
	Nan::SetPrototypeMethod(tpl, "getArrowWidthMaxValue", GetArrowWidthMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetArrowWidthMinValue", GetArrowWidthMinValue);
	Nan::SetPrototypeMethod(tpl, "getArrowWidthMinValue", GetArrowWidthMinValue);

	Nan::SetPrototypeMethod(tpl, "GetAutoLabel", GetAutoLabel);
	Nan::SetPrototypeMethod(tpl, "getAutoLabel", GetAutoLabel);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetLabel", GetLabel);
	Nan::SetPrototypeMethod(tpl, "getLabel", GetLabel);

	Nan::SetPrototypeMethod(tpl, "GetLabelFactor", GetLabelFactor);
	Nan::SetPrototypeMethod(tpl, "getLabelFactor", GetLabelFactor);

	Nan::SetPrototypeMethod(tpl, "GetLabelFactorMaxValue", GetLabelFactorMaxValue);
	Nan::SetPrototypeMethod(tpl, "getLabelFactorMaxValue", GetLabelFactorMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetLabelFactorMinValue", GetLabelFactorMinValue);
	Nan::SetPrototypeMethod(tpl, "getLabelFactorMinValue", GetLabelFactorMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLabelFormat", GetLabelFormat);
	Nan::SetPrototypeMethod(tpl, "getLabelFormat", GetLabelFormat);

	Nan::SetPrototypeMethod(tpl, "GetLabelTextProperty", GetLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getLabelTextProperty", GetLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetLength", GetLength);
	Nan::SetPrototypeMethod(tpl, "getLength", GetLength);

	Nan::SetPrototypeMethod(tpl, "GetMaximumArrowSize", GetMaximumArrowSize);
	Nan::SetPrototypeMethod(tpl, "getMaximumArrowSize", GetMaximumArrowSize);

	Nan::SetPrototypeMethod(tpl, "GetMaximumArrowSizeMaxValue", GetMaximumArrowSizeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumArrowSizeMaxValue", GetMaximumArrowSizeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMaximumArrowSizeMinValue", GetMaximumArrowSizeMinValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumArrowSizeMinValue", GetMaximumArrowSizeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMinimumArrowSize", GetMinimumArrowSize);
	Nan::SetPrototypeMethod(tpl, "getMinimumArrowSize", GetMinimumArrowSize);

	Nan::SetPrototypeMethod(tpl, "GetMinimumArrowSizeMaxValue", GetMinimumArrowSizeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMinimumArrowSizeMaxValue", GetMinimumArrowSizeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMinimumArrowSizeMinValue", GetMinimumArrowSizeMinValue);
	Nan::SetPrototypeMethod(tpl, "getMinimumArrowSizeMinValue", GetMinimumArrowSizeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetRadius", GetRadius);
	Nan::SetPrototypeMethod(tpl, "getRadius", GetRadius);

	Nan::SetPrototypeMethod(tpl, "HasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "hasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

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

	Nan::SetPrototypeMethod(tpl, "ReleaseGraphicsResources", ReleaseGraphicsResources);
	Nan::SetPrototypeMethod(tpl, "releaseGraphicsResources", ReleaseGraphicsResources);

	Nan::SetPrototypeMethod(tpl, "RenderOpaqueGeometry", RenderOpaqueGeometry);
	Nan::SetPrototypeMethod(tpl, "renderOpaqueGeometry", RenderOpaqueGeometry);

	Nan::SetPrototypeMethod(tpl, "RenderOverlay", RenderOverlay);
	Nan::SetPrototypeMethod(tpl, "renderOverlay", RenderOverlay);

	Nan::SetPrototypeMethod(tpl, "RenderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "renderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);

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

	Nan::SetPrototypeMethod(tpl, "SetArrowLength", SetArrowLength);
	Nan::SetPrototypeMethod(tpl, "setArrowLength", SetArrowLength);

	Nan::SetPrototypeMethod(tpl, "SetArrowPlacement", SetArrowPlacement);
	Nan::SetPrototypeMethod(tpl, "setArrowPlacement", SetArrowPlacement);

	Nan::SetPrototypeMethod(tpl, "SetArrowPlacementToBoth", SetArrowPlacementToBoth);
	Nan::SetPrototypeMethod(tpl, "setArrowPlacementToBoth", SetArrowPlacementToBoth);

	Nan::SetPrototypeMethod(tpl, "SetArrowPlacementToNone", SetArrowPlacementToNone);
	Nan::SetPrototypeMethod(tpl, "setArrowPlacementToNone", SetArrowPlacementToNone);

	Nan::SetPrototypeMethod(tpl, "SetArrowPlacementToPoint1", SetArrowPlacementToPoint1);
	Nan::SetPrototypeMethod(tpl, "setArrowPlacementToPoint1", SetArrowPlacementToPoint1);

	Nan::SetPrototypeMethod(tpl, "SetArrowPlacementToPoint2", SetArrowPlacementToPoint2);
	Nan::SetPrototypeMethod(tpl, "setArrowPlacementToPoint2", SetArrowPlacementToPoint2);

	Nan::SetPrototypeMethod(tpl, "SetArrowStyle", SetArrowStyle);
	Nan::SetPrototypeMethod(tpl, "setArrowStyle", SetArrowStyle);

	Nan::SetPrototypeMethod(tpl, "SetArrowStyleToFilled", SetArrowStyleToFilled);
	Nan::SetPrototypeMethod(tpl, "setArrowStyleToFilled", SetArrowStyleToFilled);

	Nan::SetPrototypeMethod(tpl, "SetArrowStyleToHollow", SetArrowStyleToHollow);
	Nan::SetPrototypeMethod(tpl, "setArrowStyleToHollow", SetArrowStyleToHollow);

	Nan::SetPrototypeMethod(tpl, "SetArrowStyleToOpen", SetArrowStyleToOpen);
	Nan::SetPrototypeMethod(tpl, "setArrowStyleToOpen", SetArrowStyleToOpen);

	Nan::SetPrototypeMethod(tpl, "SetArrowWidth", SetArrowWidth);
	Nan::SetPrototypeMethod(tpl, "setArrowWidth", SetArrowWidth);

	Nan::SetPrototypeMethod(tpl, "SetAutoLabel", SetAutoLabel);
	Nan::SetPrototypeMethod(tpl, "setAutoLabel", SetAutoLabel);

	Nan::SetPrototypeMethod(tpl, "SetLabel", SetLabel);
	Nan::SetPrototypeMethod(tpl, "setLabel", SetLabel);

	Nan::SetPrototypeMethod(tpl, "SetLabelFactor", SetLabelFactor);
	Nan::SetPrototypeMethod(tpl, "setLabelFactor", SetLabelFactor);

	Nan::SetPrototypeMethod(tpl, "SetLabelFormat", SetLabelFormat);
	Nan::SetPrototypeMethod(tpl, "setLabelFormat", SetLabelFormat);

	Nan::SetPrototypeMethod(tpl, "SetLabelTextProperty", SetLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setLabelTextProperty", SetLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetMaximumArrowSize", SetMaximumArrowSize);
	Nan::SetPrototypeMethod(tpl, "setMaximumArrowSize", SetMaximumArrowSize);

	Nan::SetPrototypeMethod(tpl, "SetMinimumArrowSize", SetMinimumArrowSize);
	Nan::SetPrototypeMethod(tpl, "setMinimumArrowSize", SetMinimumArrowSize);

	Nan::SetPrototypeMethod(tpl, "SetRadius", SetRadius);
	Nan::SetPrototypeMethod(tpl, "setRadius", SetRadius);

	Nan::SetPrototypeMethod(tpl, "ShallowCopy", ShallowCopy);
	Nan::SetPrototypeMethod(tpl, "shallowCopy", ShallowCopy);

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

void VtkLeaderActor2DWrap::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<vtkLeaderActor2D> native = vtkSmartPointer<vtkLeaderActor2D>::New();
		VtkLeaderActor2DWrap* obj = new VtkLeaderActor2DWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkLeaderActor2DWrap::GetLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)wrapper->native.GetPointer();
	vtkTextProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLabelTextProperty();
	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 VtkLeaderActor2DWrap::GetLength(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLength();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

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

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

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

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

void VtkLeaderActor2DWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderOpaqueGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLeaderActor2DWrap::RenderOverlay(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderOverlay(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLeaderActor2DWrap::RenderTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderTranslucentPolygonalGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkLeaderActor2DWrap::SetLabel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)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->SetLabel(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkLeaderActor2DWrap::SetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)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->SetLabelFormat(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLeaderActor2DWrap::SetLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLeaderActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkLeaderActor2DWrap>(info.Holder());
	vtkLeaderActor2D *native = (vtkLeaderActor2D *)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->SetLabelTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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