/* 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 "vtkAxisActor2DWrap.h"
#include "vtkObjectWrap.h"
#include "vtkCoordinateWrap.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> VtkAxisActor2DWrap::ptpl;

VtkAxisActor2DWrap::VtkAxisActor2DWrap()
{ }

VtkAxisActor2DWrap::VtkAxisActor2DWrap(vtkSmartPointer<vtkAxisActor2D> _native)
{ native = _native; }

VtkAxisActor2DWrap::~VtkAxisActor2DWrap()
{ }

void VtkAxisActor2DWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkAxisActor2D").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("AxisActor2D").ToLocalChecked(), ConstructorGetter);
}

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

void VtkAxisActor2DWrap::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("VtkAxisActor2DWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AdjustLabelsOff", AdjustLabelsOff);
	Nan::SetPrototypeMethod(tpl, "adjustLabelsOff", AdjustLabelsOff);

	Nan::SetPrototypeMethod(tpl, "AdjustLabelsOn", AdjustLabelsOn);
	Nan::SetPrototypeMethod(tpl, "adjustLabelsOn", AdjustLabelsOn);

	Nan::SetPrototypeMethod(tpl, "AxisVisibilityOff", AxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "axisVisibilityOff", AxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "AxisVisibilityOn", AxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "axisVisibilityOn", AxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "GetAdjustLabels", GetAdjustLabels);
	Nan::SetPrototypeMethod(tpl, "getAdjustLabels", GetAdjustLabels);

	Nan::SetPrototypeMethod(tpl, "GetAdjustedNumberOfLabels", GetAdjustedNumberOfLabels);
	Nan::SetPrototypeMethod(tpl, "getAdjustedNumberOfLabels", GetAdjustedNumberOfLabels);

	Nan::SetPrototypeMethod(tpl, "GetAdjustedRange", GetAdjustedRange);
	Nan::SetPrototypeMethod(tpl, "getAdjustedRange", GetAdjustedRange);

	Nan::SetPrototypeMethod(tpl, "GetAxisVisibility", GetAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getAxisVisibility", GetAxisVisibility);

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

	Nan::SetPrototypeMethod(tpl, "GetFontFactor", GetFontFactor);
	Nan::SetPrototypeMethod(tpl, "getFontFactor", GetFontFactor);

	Nan::SetPrototypeMethod(tpl, "GetFontFactorMaxValue", GetFontFactorMaxValue);
	Nan::SetPrototypeMethod(tpl, "getFontFactorMaxValue", GetFontFactorMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetFontFactorMinValue", GetFontFactorMinValue);
	Nan::SetPrototypeMethod(tpl, "getFontFactorMinValue", GetFontFactorMinValue);

	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, "GetLabelVisibility", GetLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "getLabelVisibility", GetLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "GetMinorTickLength", GetMinorTickLength);
	Nan::SetPrototypeMethod(tpl, "getMinorTickLength", GetMinorTickLength);

	Nan::SetPrototypeMethod(tpl, "GetMinorTickLengthMaxValue", GetMinorTickLengthMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMinorTickLengthMaxValue", GetMinorTickLengthMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMinorTickLengthMinValue", GetMinorTickLengthMinValue);
	Nan::SetPrototypeMethod(tpl, "getMinorTickLengthMinValue", GetMinorTickLengthMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabels", GetNumberOfLabels);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabels", GetNumberOfLabels);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabelsMaxValue", GetNumberOfLabelsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabelsMaxValue", GetNumberOfLabelsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabelsMinValue", GetNumberOfLabelsMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabelsMinValue", GetNumberOfLabelsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfMinorTicks", GetNumberOfMinorTicks);
	Nan::SetPrototypeMethod(tpl, "getNumberOfMinorTicks", GetNumberOfMinorTicks);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfMinorTicksMaxValue", GetNumberOfMinorTicksMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfMinorTicksMaxValue", GetNumberOfMinorTicksMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfMinorTicksMinValue", GetNumberOfMinorTicksMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfMinorTicksMinValue", GetNumberOfMinorTicksMinValue);

	Nan::SetPrototypeMethod(tpl, "GetPoint1Coordinate", GetPoint1Coordinate);
	Nan::SetPrototypeMethod(tpl, "getPoint1Coordinate", GetPoint1Coordinate);

	Nan::SetPrototypeMethod(tpl, "GetPoint2Coordinate", GetPoint2Coordinate);
	Nan::SetPrototypeMethod(tpl, "getPoint2Coordinate", GetPoint2Coordinate);

	Nan::SetPrototypeMethod(tpl, "GetRange", GetRange);
	Nan::SetPrototypeMethod(tpl, "getRange", GetRange);

	Nan::SetPrototypeMethod(tpl, "GetRulerDistance", GetRulerDistance);
	Nan::SetPrototypeMethod(tpl, "getRulerDistance", GetRulerDistance);

	Nan::SetPrototypeMethod(tpl, "GetRulerDistanceMaxValue", GetRulerDistanceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRulerDistanceMaxValue", GetRulerDistanceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRulerDistanceMinValue", GetRulerDistanceMinValue);
	Nan::SetPrototypeMethod(tpl, "getRulerDistanceMinValue", GetRulerDistanceMinValue);

	Nan::SetPrototypeMethod(tpl, "GetRulerMode", GetRulerMode);
	Nan::SetPrototypeMethod(tpl, "getRulerMode", GetRulerMode);

	Nan::SetPrototypeMethod(tpl, "GetSizeFontRelativeToAxis", GetSizeFontRelativeToAxis);
	Nan::SetPrototypeMethod(tpl, "getSizeFontRelativeToAxis", GetSizeFontRelativeToAxis);

	Nan::SetPrototypeMethod(tpl, "GetTickLength", GetTickLength);
	Nan::SetPrototypeMethod(tpl, "getTickLength", GetTickLength);

	Nan::SetPrototypeMethod(tpl, "GetTickLengthMaxValue", GetTickLengthMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTickLengthMaxValue", GetTickLengthMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTickLengthMinValue", GetTickLengthMinValue);
	Nan::SetPrototypeMethod(tpl, "getTickLengthMinValue", GetTickLengthMinValue);

	Nan::SetPrototypeMethod(tpl, "GetTickOffset", GetTickOffset);
	Nan::SetPrototypeMethod(tpl, "getTickOffset", GetTickOffset);

	Nan::SetPrototypeMethod(tpl, "GetTickOffsetMaxValue", GetTickOffsetMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTickOffsetMaxValue", GetTickOffsetMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTickOffsetMinValue", GetTickOffsetMinValue);
	Nan::SetPrototypeMethod(tpl, "getTickOffsetMinValue", GetTickOffsetMinValue);

	Nan::SetPrototypeMethod(tpl, "GetTickVisibility", GetTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getTickVisibility", GetTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetTitle", GetTitle);
	Nan::SetPrototypeMethod(tpl, "getTitle", GetTitle);

	Nan::SetPrototypeMethod(tpl, "GetTitlePosition", GetTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getTitlePosition", GetTitlePosition);

	Nan::SetPrototypeMethod(tpl, "GetTitleTextProperty", GetTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "getTitleTextProperty", GetTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetTitleVisibility", GetTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "getTitleVisibility", GetTitleVisibility);

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

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

	Nan::SetPrototypeMethod(tpl, "LabelVisibilityOff", LabelVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "labelVisibilityOff", LabelVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "LabelVisibilityOn", LabelVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "labelVisibilityOn", LabelVisibilityOn);

	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, "RulerModeOff", RulerModeOff);
	Nan::SetPrototypeMethod(tpl, "rulerModeOff", RulerModeOff);

	Nan::SetPrototypeMethod(tpl, "RulerModeOn", RulerModeOn);
	Nan::SetPrototypeMethod(tpl, "rulerModeOn", RulerModeOn);

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

	Nan::SetPrototypeMethod(tpl, "SetAdjustLabels", SetAdjustLabels);
	Nan::SetPrototypeMethod(tpl, "setAdjustLabels", SetAdjustLabels);

	Nan::SetPrototypeMethod(tpl, "SetAxisVisibility", SetAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setAxisVisibility", SetAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetFontFactor", SetFontFactor);
	Nan::SetPrototypeMethod(tpl, "setFontFactor", SetFontFactor);

	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, "SetLabelVisibility", SetLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "setLabelVisibility", SetLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "SetMinorTickLength", SetMinorTickLength);
	Nan::SetPrototypeMethod(tpl, "setMinorTickLength", SetMinorTickLength);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfLabels", SetNumberOfLabels);
	Nan::SetPrototypeMethod(tpl, "setNumberOfLabels", SetNumberOfLabels);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfMinorTicks", SetNumberOfMinorTicks);
	Nan::SetPrototypeMethod(tpl, "setNumberOfMinorTicks", SetNumberOfMinorTicks);

	Nan::SetPrototypeMethod(tpl, "SetPoint1", SetPoint1);
	Nan::SetPrototypeMethod(tpl, "setPoint1", SetPoint1);

	Nan::SetPrototypeMethod(tpl, "SetPoint2", SetPoint2);
	Nan::SetPrototypeMethod(tpl, "setPoint2", SetPoint2);

	Nan::SetPrototypeMethod(tpl, "SetRange", SetRange);
	Nan::SetPrototypeMethod(tpl, "setRange", SetRange);

	Nan::SetPrototypeMethod(tpl, "SetRulerDistance", SetRulerDistance);
	Nan::SetPrototypeMethod(tpl, "setRulerDistance", SetRulerDistance);

	Nan::SetPrototypeMethod(tpl, "SetRulerMode", SetRulerMode);
	Nan::SetPrototypeMethod(tpl, "setRulerMode", SetRulerMode);

	Nan::SetPrototypeMethod(tpl, "SetSizeFontRelativeToAxis", SetSizeFontRelativeToAxis);
	Nan::SetPrototypeMethod(tpl, "setSizeFontRelativeToAxis", SetSizeFontRelativeToAxis);

	Nan::SetPrototypeMethod(tpl, "SetTickLength", SetTickLength);
	Nan::SetPrototypeMethod(tpl, "setTickLength", SetTickLength);

	Nan::SetPrototypeMethod(tpl, "SetTickOffset", SetTickOffset);
	Nan::SetPrototypeMethod(tpl, "setTickOffset", SetTickOffset);

	Nan::SetPrototypeMethod(tpl, "SetTickVisibility", SetTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setTickVisibility", SetTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetTitle", SetTitle);
	Nan::SetPrototypeMethod(tpl, "setTitle", SetTitle);

	Nan::SetPrototypeMethod(tpl, "SetTitlePosition", SetTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setTitlePosition", SetTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetTitleTextProperty", SetTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "setTitleTextProperty", SetTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetTitleVisibility", SetTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "setTitleVisibility", SetTitleVisibility);

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

	Nan::SetPrototypeMethod(tpl, "SizeFontRelativeToAxisOff", SizeFontRelativeToAxisOff);
	Nan::SetPrototypeMethod(tpl, "sizeFontRelativeToAxisOff", SizeFontRelativeToAxisOff);

	Nan::SetPrototypeMethod(tpl, "SizeFontRelativeToAxisOn", SizeFontRelativeToAxisOn);
	Nan::SetPrototypeMethod(tpl, "sizeFontRelativeToAxisOn", SizeFontRelativeToAxisOn);

	Nan::SetPrototypeMethod(tpl, "TickVisibilityOff", TickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "tickVisibilityOff", TickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TickVisibilityOn", TickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "tickVisibilityOn", TickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "TitleVisibilityOff", TitleVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "titleVisibilityOff", TitleVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TitleVisibilityOn", TitleVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "titleVisibilityOn", TitleVisibilityOn);

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

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

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

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

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

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

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

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

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

void VtkAxisActor2DWrap::GetAdjustedRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetAdjustedRange(
			(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[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; 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->GetAdjustedRange(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

void VtkAxisActor2DWrap::GetLabelFactor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::GetLabelFactorMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::GetLabelFactorMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::GetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::GetLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::GetLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLabelVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActor2DWrap::GetRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRange();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
	info.GetReturnValue().Set(at);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActor2DWrap::HasTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::LabelVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->LabelVisibilityOff();
}

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

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

void VtkAxisActor2DWrap::ReleaseGraphicsResources(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::RenderOverlay(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::RenderTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::RulerModeOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->RulerModeOff();
}

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

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

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

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

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

void VtkAxisActor2DWrap::SetLabelFactor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::SetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::SetLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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 VtkAxisActor2DWrap::SetLabelVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLabelVisibility(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

void VtkAxisActor2DWrap::SetPoint1(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint1(
			(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[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; 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->SetPoint1(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPoint1(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkAxisActor2DWrap::SetPoint2(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint2(
			(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[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; 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->SetPoint2(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPoint2(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkAxisActor2DWrap::SetRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetRange(
			(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[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; 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->SetRange(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetRange(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

void VtkAxisActor2DWrap::ShallowCopy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActor2DWrap>(info.Holder());
	vtkAxisActor2D *native = (vtkAxisActor2D *)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");
}

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

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

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

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

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

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